leetcode Path Sum && Path Sum ||

最新推荐文章于 2016-04-12 20:16:04 发布

原创最新推荐文章于 2016-04-12 20:16:04 发布 · 363 阅读

0 ·

CC 4.0 BY-SA版权

leetcode Fighting 专栏收录该内容

133 篇文章

订阅专栏

本文详细介绍了LeetCode中路径总和问题的两种解决方案，一种是判断是否存在满足特定和的路径，另一种是找出所有满足特定和的路径。通过递归算法实现了对二叉树的遍历，并记录了路径信息。

Path Sum

此题同 leetcode Sum Root to Leaf Numbers 解法，递归遍历时改变每个节点的值，该值为从起点到当前节点的路径和。

代码

class Solution {
public:
    bool hasPathSum(TreeNode *root, int sum) {
       
       flag = false;
       hasPathSumHelper(root, sum);
       return flag;
    
    }
    
    void hasPathSumHelper(TreeNode *root, int sum)
    {
            if(root==NULL)
                return ;
                
            if(!root->left&&!root->right&&root->val==sum)
            {
                flag = true;
                return ;
            }
     
            if(root->left!=NULL)
            {
                root->left->val += root->val;
                hasPathSumHelper(root->left,sum);
            }
            if(root->right!=NULL)
            {
                root->right->val += root->val;
                hasPathSumHelper(root->right,sum);
            }
      
        
    }
    
private:
    bool flag;
    
};

Path Sum ||

与Path Sum 大致相同，但要求输出所有路径和满足条件的路径，因此开辟空间保存路径信息即可。

代码

class Solution {
public:
    vector<vector<int> > pathSum(TreeNode *root, int sum) {
        vector<vector<int> > result;
        vector<int> onePath;
        if(root==NULL)
            return result;
        onePath.push_back(root->val);
        pathSumHelper(root, sum, onePath, result);
        return result;
    }
    
    void pathSumHelper(TreeNode *root, int sum, vector<int> onePath, vector<vector<int> > &result)
    {
        
        if(root==NULL)
            return ;
        
        if(!root->left&&!root->right&&root->val==sum)
        {
            result.push_back(onePath);
        }
        
        if(root->left)
        {
            onePath.push_back(root->left->val);
            root->left->val += root->val;
            pathSumHelper(root->left, sum, onePath, result);
            onePath.pop_back();
        }
        
        if(root->right)
        {
            onePath.push_back(root->right->val);
            root->right->val += root->val;
            pathSumHelper(root->right, sum, onePath, result);
            onePath.pop_back();
        }
        
    }
};