[LeetCode] Path Sum II

Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum.

For example:
Given the below binary tree and sum = 22,

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1

return

[
   [5,4,11,2],
   [5,8,4,5]
]

Recursive like the Question Path Sum, just use a vector<int> to store the result.
Just don't forget the backtracking.
After searching the left node and right node, DO NOT forget to pop the node added in the vector.
Ideas see Path Sum.
C++

void GetsumPath(vector<vector<int>> &result,
                vector<int> &path,
                int target,
                int sum,
                TreeNode *root){
    if(root == NULL) return;
    sum += root->val;
    path.push_back(root->val);
    if(target == sum && root->left == NULL && root->right == NULL){
        result.push_back(path);
    }
    
    GetsumPath(result,path,target,sum,root->left);
        
    GetsumPath(result,path,target,sum,root->right);
    
    path.pop_back();
    sum -= root->val;
    return;
}
vector<vector<int> > pathSum(TreeNode *root, int sum) {
     vector<vector<int>> result;
     vector<int> path;
     GetsumPath(result,path,sum,0,root);
     return result;
}

Java

public class Solution {
    ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> path = new ArrayList<Integer>();
	public ArrayList<ArrayList<Integer>> pathSum(TreeNode root, int sum) {
        getSum(root, 0, sum);
        return result;
    }
	public void getSum(TreeNode root, int sum, int target){
		if(root == null) return;
		sum+= root.val;
		path.add(root.val);
		if(root.left == null && root.right == null && sum== target)
			result.add(new ArrayList<>(path));
		getSum(root.left, sum, target);
		getSum(root.right, sum, target);
		sum-=root.val;
		path.remove(path.size()-1);
		return;
	}
}

注意要用

new ArrayList<>(path)

不能直接将path存到result中，否则后面remove也会将其删掉