Path Sum II (LeetCode)

Question:

https://oj.leetcode.com/problems/path-sum-ii/

 

解答：

碰到这种求所有解的，要不是BFS，要不DFS。DFS用递归简单些，如果iterative，就需要用到stack，BFS需要用到queue。

DFS recursive 只需要维持一个vector<int> array, 当前点处理前push入array，处理完了后pop出array。BFS queue里有多少个点就需要维持多少个vector<int>。

class Solution {
public:
    vector<vector<int> > pathSum(TreeNode *root, int sum) {
        vector<int> path;
        vector<vector<int>> ret;
        //DFSRecurPathSum(root, sum, 0, path, ret);
        BFSIterative(root, sum, ret);
        
        return ret;
    }
    
    void BFSIterative(TreeNode* node, int sum, vector<vector<int>>& ret)
    {
        struct Path
        {
            TreeNode* node;
            int sum;
            vector<int> list;
        };
        
        if (!node)
            return;
        
        std::queue<Path> q;
        Path path;
        path.node = node;
        path.sum = node->val;
        path.list.push_back(node->val);
        q.push(path);
        
        while (!q.empty())
        {
            Path& currPath = q.front();

            if (!currPath.node->left && !currPath.node->right)
            {
                if (currPath.sum == sum)
                    ret.push_back(currPath.list);
            }
            else
            {
                if (currPath.node->left && currPath.node->right)
                {
                    Path newPath;
                    newPath.node = currPath.node->left;
                    newPath.sum = currPath.sum+newPath.node->val;
                    newPath.list = currPath.list;
                    newPath.list.push_back(newPath.node->val);
                    q.push(newPath);
                }
                
                currPath.node = currPath.node->right ? currPath.node->right : currPath.node->left;
                currPath.sum += currPath.node->val;
                currPath.list.push_back(currPath.node->val);
                q.push(currPath);
            }

            q.pop();
        }
    }
    
    void DFSRecurPathSum(TreeNode* node, int sum, int prev_sum, vector<int>& path, vector<vector<int>>& ret)
    {
        if (!node)
            return;
        
        prev_sum += node->val;
        path.push_back(node->val);
        
        if (!node->left && !node->right)
        {
            if(prev_sum == sum)
            {
                ret.push_back(path);
            }
        }

        if (node->left)
            DFSRecurPathSum(node->left, sum, prev_sum, path, ret);

        if (node->right)
            DFSRecurPathSum(node->right, sum, prev_sum, path, ret);

        // pop current node
        path.pop_back();
    }
};