437. Path Sum III 二刷

最新推荐文章于 2021-01-14 21:48:33 发布

NewCoder_BL

最新推荐文章于 2021-01-14 21:48:33 发布

阅读量116

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/u011934885/article/details/86467829

版权

leetcode 专栏收录该内容

134 篇文章 0 订阅

订阅专栏

You are given a binary tree in which each node contains an integer value. Find the number of paths that sum to a given value. The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).

The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.

Example:

root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8

      10
     /  \
    5   -3
   / \    \
  3   2   11
 / \   \
3  -2   1

Return 3. The paths that sum to 8 are:

1.  5 -> 3
2.  5 -> 2 -> 1
3. -3 -> 11

这题之前做的时候给出的做法是：递归，如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int pathSum(TreeNode* root, int sum) {
        if (root == NULL) return 0;
        return cumulate_helper(root, sum, 0) + pathSum(root->left, sum) + pathSum(root->right, sum);
    }
    
    int cumulate_helper(TreeNode* root, int sum, int tempsum) {
        if (root == NULL) return 0;
        tempsum += root->val;
        return (tempsum == sum) + cumulate_helper(root->left, sum, tempsum) + cumulate_helper(root->right, sum, tempsum);
    }
};

这种写法最为简单也最好懂，但效率并不高，可想而知，同一个路径上，因为起点不同，我们做了很多的重复计算。
今天我们给出另一个思路下更高效的做法。

方法二： backtracking 类似，存储路径再讨论
其实这题就是找所有从上而下的路径和，起点随意，和为固定值就行。所以我们考虑把路径存起来讨论，完整路径在那，怎么求和都方便。

class Solution {
public:
    int pathSum(TreeNode* root, int sum) {
        if (root == NULL) return 0;
        int res = 0;
        vector<TreeNode*> path;
        helper(root, sum, 0, res, path);
        return res;
    }
    void helper(TreeNode* root, int sum, int currsum, int& res, vector<TreeNode*>& path) {
        if (root == NULL) return;
        currsum += root->val;
        if (currsum == sum) res++;
        path.push_back(root);
        int temp = currsum;
        for (int i = 0; i < path.size() - 1; i++) {
            temp -= path[i]->val;
            if (temp == sum) res++;
        }
        helper(root->left, sum, currsum, res, path);
        helper(root->right, sum, currsum, res, path);
        path.pop_back();
        return;
    }
};

方法三：优化方法二
方法二本质和方法一区别不大，还是做了很多重复的计算。我们想省去那些重复的计算，基本的路数就是把已有的计算结果存起来，重复使用。空间换时间。这里我们可以建一个hash table, 把之前的路径节点和对应的求和值存起来。
值得注意的是，得把hash[0]预置为1。否则会漏算掉从根节点开始的完整路径，不这么做也行，每次递归时判断一下currsum == sum就行，等于的话res++.

class Solution {
public:
    int pathSum(TreeNode* root, int sum) {
        int res = 0;
        if (root == NULL) return res;
        unordered_map<int, int> hash;
        hash[0] = 1;
        helper(root, sum, hash, 0, res);
        return res;
    }
    void helper(TreeNode* root, int sum, unordered_map<int, int>& hash, int currsum, int& res) {
        if (root == NULL) return;
        currsum += root->val;
        res += hash[currsum - sum];
        hash[currsum]++;
        helper(root->left, sum, hash, currsum, res);
        helper(root->right, sum, hash, currsum, res);
        hash[currsum]--;
        return;
    }
};