【leetcode】【easy】437. Path Sum III

437. Path Sum III

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

题目链接：https://leetcode-cn.com/problems/path-sum-iii/

 

思路

本题的sum是从任意位置开始，任意位置结束的。

注意一点：由于树中有负值元素，路径可以覆盖。中途找到解不能直接终止递归，因为可能往下走还能满足条件。

法一：递归

思路一：每次考虑当前节点为结束节点

时间复杂度O(n)，空间复杂度不考虑递归是O(logn)。

/**
 * 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) return 0;
        vector<int> rec;
        return path(root, sum, rec);
    }
    int path(TreeNode* root, int sum, vector<int> rec){
        if(!root) return 0;
        int res = 0;
        for(int i=0;i<rec.size();++i){
            rec[i] += root->val;
            if(rec[i]==sum) ++res;
        }
        if(root->val == sum) ++res;
        rec.push_back(root->val);
        return res + path(root->left, sum, rec) + path(root->right, sum, rec);
    }
};

编程笔记：递归中传入引用变量，效果是所有层递归函数公用同一个变量，中途被改变，层都能收到；不是引用则只要本函数内被改变，和传递给下层的被改变。

思路二：每次考虑当前节点为开始节点

时间复杂度O(nlgn)，空间复杂度不考虑递归是O(1)。

/**
 * 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) return 0;
        return path(root, sum) + pathSum(root->left, sum) + pathSum(root->right, sum);
    }
    int path(TreeNode* root, int sum){
        if(!root) return 0;
        int l = path(root->left, sum-root->val);
        int r = path(root->right, sum-root->val);
        return (sum==root->val)?1+l+r:l+r;
    }
};

法二：非递归

暂时不写