简洁版

class Solution {
    vector<int> path;
    vector<vector<int>> res;
public:
    vector<vector<int>> findPath(TreeNode* root, int sum) {
        dfs(root, sum);
        return res;
    }

    void dfs(TreeNode* root, int sum) {
        if (!root) return;
        sum = sum - root->val;

        path.push_back(root->val);
        if (!root->left && !root->right && !sum) res.push_back(path);
        dfs(root->left, sum);
        dfs(root->right, sum);
        path.pop_back();
    }
};

麻烦各位帮忙看下 ，这个代码为什么会通不过呢，打印出来是对的但是，返回不对。

# Definition for a binary tree node.
# class TreeNode(object):
# def init(self, x):
# self.val = x
# self.left = None
# self.right = None

class Solution(object):

def findPath(self, root, sum):
    """
    :type root: TreeNode
    :type sum: int
    :rtype: List[List[int]]
    """
    self.path = []
    self.res = []
    self.dfs(root,sum)
    return self.res
def dfs(self,root,sum):
    if not root:return
    self.path.append(root.val)
    sum -= root.val
    if not root.left and not root.right and not sum:
        self.res.append(self.path)
        print(self.res)
    self.dfs(root.left,sum)
    self.dfs(root.right,sum)
    self.path.pop()

sum += root->val;这一步回溯不需要吗？
我的代码也ac了，觉得应该要的啊。

/**
 * 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:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> findPath(TreeNode* root, int sum) {
        if(!root) return res;
        dfs(root,sum);
        return res;
    }

    void dfs(TreeNode* root,int sum){
        if(!root) return;

        sum -= root->val;
        path.push_back(root->val);
        if(!root->left && !root->right && !sum) res.push_back(path);
        dfs(root->left,sum);
        dfs(root->right,sum);
        sum += root->val;
        path.pop_back();
    }
};

感觉是因为dfs函数每次调用时都传递了sum参数，导致sum被用作一个局部变量，在回溯时不会改变之前的值。因此你加或不加sum += root->val;都不影响结果。
但是如果把sum从函数的接口中删除，sum作为一个全局变量，就必须恢复现场从而进行回溯。
代码

class Solution {
public:
    int s ;
    vector<vector<int>> res; 
    vector<int> path;
    vector<vector<int>> findPath(TreeNode* root, int sum) {
        s = sum;
        dfs(root);
        return res;
    }
    void dfs(TreeNode *root) {

        if(!root) return;
        path.push_back(root->val);
        s -= root->val;

        if(!root->left && !root->right && !s) res.push_back(path);
        if(root->left)  dfs(root->left);
        if(root->right) dfs(root->right);
        path.pop_back();
        s += root->val;
    }
};

终于搞明白了，path 是全局变量，每一层都能看到，都能修改它，所以要回溯（恢复原状），而 sum 是局部变量，修改它只在当前这一层起作用，所以不用回溯（恢复原状）

请问最后的path.pop_back();处理是什么意思呢

回溯

全局的sum并没有起任何的作用，去除全局sum，一样可以ac。

请仔细读读题

确实可以ac啊= =

确实可以ac啊