leetcode-113-Path Sum II

问题

题目：[leetcode-113I]

思路

和之前的那一道只是在接口上有区别而已。

代码

/**
 * 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) {
        std::vector<std::vector<int>> ret;
        std::vector<int> nodes;
        if(!root) return ret;
        dfs(root, sum, 0, nodes, ret);
        return ret;
    }
private:
    void dfs(TreeNode* root, int sum, int res, std::vector<int> nodes, std::vector<std::vector<int>>& ret){
        if(root){
            res += root->val;
            nodes.push_back(root->val);

            if(!root->left && !root->right){
                if(res==sum) ret.push_back(nodes);
            }
            dfs( root->left, sum, res, nodes, ret );
            dfs( root->right, sum, res, nodes, ret );
        }
    }
};

思路1

保持了和path sum一样的做法，在传递参数的时候，传递了path的引用，那么当前节点访问完毕之后，要把该节点退出path。

代码1

/**
 * 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) {
        std::vector<std::vector<int>> ret;
        if(!root) return ret;
        std::vector<int> path;
        dfs(root, sum, path, ret);

        return ret;
    }
private:
    void dfs(TreeNode* root, int sum, std::vector<int>& path, std::vector<std::vector<int>>& ret){
        if(!root) return;
        path.push_back(root->val);

        if(!root->left&&!root->right&&root->val==sum) ret.push_back(path);
        dfs(root->left, sum-root->val, path, ret);
        dfs(root->right, sum-root->val, path, ret);
        path.pop_back();
    }
};

思路2

二叉树的题目，对边界情况的处理比较灵活，其实就那么几种情况，如果不确定，分别试下即可。这个题dfs遍历即可。由于path是引用，所以头尾插入和删除是对称的，这样不会影响其他层次的遍历。

/**
 * 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) {
        vector<vector<int>> ret;
        if(!root) return ret;

        vector<int> path;

        dfs( root, 0, sum, path, ret );
        return ret;
    }
private:
    void dfs(TreeNode* root, int cur, int target, vector<int>& path, vector<vector<int>>& ret){
        if( root ){

            path.push_back(root->val);
            cur += root->val; // cur本身就是值传递，当前层变了之后也不会影响上一层

            if( !root->left && !root->right ){
                if( cur == target )
                    ret.push_back(path);
            }else{
                dfs(root->left, cur, target, path, ret);
                dfs(root->right, cur, target, path, ret);
            }
            path.pop_back();

        }
    }
};