leetcode-121 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.

Note: A leaf is a node with no children.

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

j解法一：递归的DFS，回溯法，记录每条正确的路径

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int> > res;
    void backtrace(vector<int> &nums,TreeNode* root, int sum)
    {
        if(root->left == NULL && root->right == NULL)
        {
            if(sum == root->val)
            {
                nums.push_back(root->val);
                res.push_back(nums);
                nums.pop_back();
            }
        }
        if(root->left)
        {
            nums.push_back(root->val);
            backtrace(nums,root->left,sum - root->val);
            nums.pop_back();
        }
        if(root->right)
        {
            nums.push_back(root->val);
            backtrace(nums,root->right,sum - root->val);
            nums.pop_back();
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        res.clear();
        if(root == NULL)
            return res;
        vector<int> nums;
        backtrace(nums,root,sum);
        return res;
    }
};

解法二: 迭代的DFS + stack（遍历到叶子结点）

使用栈记录节点，同时申请栈记录sum以及路径

出栈的时候是访问的时候，计算sum，记录路径，入栈只记录节点以及前一步的sum和路径

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int> > res;
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        res.clear();
        if(root == NULL)
            return res;
        /* DFS iterative */
        stack<TreeNode*> stknode({root});
        stack<int> stksum({sum});
        stack<vector<int> > pathstk({vector<int>({})});
        while(!stknode.empty())
        {
            
            TreeNode* p = stknode.top();
            int isum = stksum.top();
            vector<int> path = pathstk.top();
            stknode.pop();
            pathstk.pop();
            stksum.pop();
            
            isum = isum - p->val;
            path.push_back(p->val);
            if(p->left == NULL && p->right == NULL && isum == 0)
            {
                res.push_back(path);
                continue;
            }
            if(p->left)
            {    
                stknode.push(p->left);
                stksum.push(isum);
                pathstk.push(path);
                
            }
            if(p->right)
            {   
                stknode.push(p->right);
                stksum.push(isum);
                pathstk.push(path);
            }
        }
     return res;   
    }
};

解法三：BFS + queue（遍历到叶子结点）

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int> > res;
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        res.clear();
        if(root == NULL)
            return res;
        queue<TreeNode*> Q({root});
        queue<vector<int> > qPath({vector<int>({})});
        queue<int> qsum({sum});
        while(!Q.empty())
        {
            TreeNode* r = Q.front();
            vector<int> path = qPath.front();
            int isum = qsum.front();
            Q.pop();
            qPath.pop();
            qsum.pop();
            path.push_back(r->val);
            isum = isum - r->val;
            
            if(r->left == NULL && r->right == NULL && isum == 0)
            {    
                res.push_back(path);
                continue;             
            }
            if(r->left)
            {
                Q.push(r->left);
                qPath.push(path);
                qsum.push(isum);
            }
            if(r->right)
            {
                Q.push(r->right);
                qPath.push(path);
                qsum.push(isum);
            }
        }
        return res;
    }
};