112. Path Sum I & II-优快云博客

本文探讨了两个经典的二叉树路径和问题：一是判断是否存在从根节点到叶子节点的路径使得节点值之和等于给定的目标值；二是找出所有满足条件的路径。通过递归深度优先搜索的方式实现了算法，并提供了完整的C++代码实现。

112. Path Sum

原题：

Given a binary tree and a sum, determine if the tree has a
root-to-leaf path such that adding up all the values along the path
equals the given sum.

For example: Given the below binary tree and sum = 22,
              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1 
    return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.

题意：
有一棵二叉树，从它的根节点开始，走到叶子节点，如果节点val的和为sum，就返回true，如果找不到这样的路径，就返回false。

直接DFS，过程中记录当前的和。这里有几个要注意的点，因为题意要求到叶节点才停止，因此中间加起来的和等于目标sum了也不能返回。而且，要注意到有负数的存在，因此不能在和大于目标值的时候进行剪枝。

代码：

/**
 * 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:
    bool hasPathSum(TreeNode* root, int sum) {
        if(!root) {
            return false;
        }
        return helper(root, sum, root->val);
    }

    bool helper(TreeNode* node, const int& target, int sum) {
        // cout << "Now sum: " << sum << endl;

        if(!(node->left || node->right)) {
            return sum == target;
        }

        bool l=false, r=false;
        if(node->left) {
            int ln = node->left->val;
            l = helper(node->left, target, sum+ln);
        }

        if(node->right) {
            int rn = node->right->val;
            r = helper(node->right, target, sum+rn);
        }

        return l||r;
    }
};

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

题意：
和上题一样找和为sum的根节点到叶节点的通路，但是这次要返回所有满足条件的路径的集合。

因此要记录的就是这个集合，以及遍历的路径。路径应该用stack来实现，但是为了满足题意，用vector代替，push_back()和pop_back()函数。在回溯过程中，注意保持path的正确性。

在遍历的过程中，把节点的val添加到路径中，当找到有满足条件的路径的时候，并不是返回数值，而是把当前路径push到最后的集合中，然后回溯，继续DFS。

代码：

/**
 * 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>> pathSum(TreeNode* root, int sum) {
        if(!root) {
            return vector<vector<int>>();
        }
        vector<vector<int> > ret;
        vector<int> path(1, root->val);
        helper(root, sum, root->val, ret, path);
        return ret;
    }

    void helper(TreeNode* node, const int& target, int sum, vector<vector<int> >& ret, vector<int>& path) {
        // cout << "Now sum: " << sum << endl;

        if(!(node->left || node->right)) {
            if(sum == target) {
                ret.push_back(path);
            }
        }

        if(node->left) {
            int ln = node->left->val;
            path.push_back(ln);
            helper(node->left, target, sum+ln, ret, path);
            path.pop_back();
        }

        if(node->right) {
            int rn = node->right->val;
            path.push_back(rn);
            helper(node->right, target, sum+rn, ret, path);
            path.pop_back();
        }

    }
};