113.路径总和II

/**
 * 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:
 void mypathSum(TreeNode* root, int sum, vector<int> pre, int presum, vector<vector<int>>& v)
 {
  if (!root) return;
  presum += root->val;
  if (!root->left && !root->right&&sum == presum)
  {
   pre.push_back(root->val);
   v.push_back(pre);
   return;
  }
  pre.push_back(root->val);
  mypathSum(root->left, sum, pre, presum, v);
  mypathSum(root->right, sum, pre, presum, v);
 }
 vector<vector<int>> pathSum(TreeNode* root, int sum) {
  vector<vector<int>> v;
  vector<int> pre;
  int presum = 0;
  mypathSum(root, sum, pre, presum, v);
  return v;
 }
};

思路：
递归，sum是目标路径总和，pre用来记录已走过的路径，presum用来记录已走过的路径总和，v用来记录符合条件的路径。从根节点开始，如果根节点为空，直接返回，presum加上当前节点的值，如果已走到叶节点，判断总和和目标总和是否相等，如果相等将此路径存入v。递归进入左右子树寻找。

这种算法时空复杂度都比较高

看了一下题解，改进了一下算法，用了回溯和传引用，时间和空间复杂度都降了很多。

/**
 * 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:
    void mypathSum(TreeNode* root,int sum,vector<int>& pre,int presum,vector<vector<int>>& v)
    {
       if (!root) return;
       presum += root->val;
       pre.push_back(root->val);
       if (!root->left && !root->right&&sum == presum) v.push_back(pre);
       mypathSum(root->left, sum, pre, presum, v);
       mypathSum(root->right, sum, pre, presum, v);
       pre.pop_back();
    }
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> v;
        vector<int> pre;
        int presum=0;
        mypathSum(root,sum,pre,presum,v);
        return v;
    }
};

还一种代码，思路是一模一样的，但是函数少了两个形参，可以参考一下

class Solution {
public:
    vector<vector<int>>res;
    void search(TreeNode* root, int sum, vector<int> &temp)             // 这里引用，只用了一个temp，既然深搜了，所以要用到这个技巧
    {
        if(!root) return;
        temp.push_back(root->val);
        if(!(root->left)&&!(root->right)) 
        {
            if(sum == root->val) res.push_back(temp);
        }
        search(root->left, sum - root->val, temp);
        search(root->right, sum - root->val, temp);
        temp.pop_back();                                                    // 回溯
    }

    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<int> temp ;
        search(root, sum , temp);
        return res;
    }
};