LeetCode - Path Sum II

Path Sum II

2014.1.8 05:38

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]
]

Solution:

　　This problem is a variation from LeetCode - Path Sum. The difference is that you need to find out all the paths, instead of just judging the existence of these paths.

　　To hold the result, extra arrays are needed. Also there needs to be one array passed as parameter, so as to record path during the recursion.

　　Time and space complexities are both O(n), where n is the number of nodes in the tree.

Accepted code:

// 1RE, 1AC
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> pathSum(TreeNode *root, int sum) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int i, n;
        n = result.size();
        for(i = 0; i < n; ++i){
            result[i].clear();
        }
        result.clear();
        arr.clear();
        if(root == nullptr){
            return result;
        }
        // 1RE here, forgot to push into $arr
        arr.push_back(root->val);
        dfs(root, root->val, sum);
        arr.pop_back();
        
        return result;
    }
private:
    vector<vector<int>> result;
    vector<int> arr;
    
    void dfs(TreeNode *root, int sum, int target){
        if(root == nullptr){
            return;
        }
        
        if(root->left == nullptr && root->right == nullptr){
            if(sum == target){
                result.push_back(arr);
            }
            return;
        }
        
        if(root->left != nullptr){
            arr.push_back(root->left->val);
            dfs(root->left, sum + root->left->val, target);
            arr.pop_back();
        }
        if(root->right != nullptr){
            arr.push_back(root->right->val);
            dfs(root->right, sum + root->right->val, target);
            arr.pop_back();
        }
    }
};