[LeetCode 112 113] - 路径和I & II (Path Sum I & II)

问题

给出一棵二叉树及一个和值，检查该树是否存在一条根到叶子的路径，该路径经过的所有节点值的和等于给出的和值。

例如，

给出以下二叉树及和值22:

         5
        / \
       4  8
      /   / \
    11 13 4
    / \        \
  7   2        1

函数返回true，因为存在一条根到叶子的路径5->4->11->2，其路径和为22。

 

初始思路

鉴于题目要求找到一条路径和符合要求即可，选择层次遍历二叉树是一种比较合适的选择－保证了我们首先找到的是最短的路径从而节省了时间。另外由于没有禁止修改原二叉树的值，我们在处理过程中可以把每个点的值修改为到达这点时的路径和，方便比较。至于层次遍历的方法，大家应该已经很熟悉了，使用116，117中的双vector法即可：

class Solution {
    public:
        bool hasPathSum(TreeNode *root, int sum)
        {
            if(!root)
            {
                return false;
            }
            
            treeLevel_[0].clear();
            treeLevel_[1].clear();
            
            bool flag = false;
            treeLevel_[0].push_back(root);
            
            while(!treeLevel_[flag].empty())
            {
                for(auto iter = treeLevel_[flag].begin(); iter != treeLevel_[flag].end(); ++iter)
                {
                    if(!(*iter)->left && !(*iter)->right)
                    {
                        if((*iter)->val == sum)
                        {
                            return true;
                        }
                    }
                    
                    if((*iter)->left)
                    {
                        (*iter)->left->val += (*iter)->val;
                        
                        treeLevel_[!flag].push_back((*iter)->left);
                    }
                    
                    if((*iter)->right)
                    {
                        (*iter)->right->val += (*iter)->val;

                        
                        treeLevel_[!flag].push_back((*iter)->right);
                    }
                }
                
                treeLevel_[flag].clear();
                
                flag = !flag;
            }
            
            return false;
        }
        
    private:
        
        std::vector<TreeNode*> treeLevel_[2];
    };

提交后Judge Small和Judge Large双双通过。

 

扩展问题

给出一棵二叉树及一个和值，找出符合条件的所有根到叶子的路径，这些路径经过的所有节点值的和等于给出的和值。

例如，

给出以下二叉树及和值22:

         5 
        / \
       4  8
      /   / \
    11 13 4
    / \     / \
  7   2  5    1

返回

[
  [5,4,11,2],
  [5,8,4,5]
]

 

扩展问题初始思路

题目要求找出所有符合条件的路径，意味着不管用什么方法都必须把所有节点遍历一遍。如果还是使用前面的层次遍历，因为是广度优先遍历，需要同时跟踪多条路径的和，直到走到叶子节点。因此在这里我们尝试使用普通的递归中序遍历，由于这是一种深度优先遍历，通过进栈及出栈操作，可以做到一次只需跟踪一条路径即可：

class Solution113 {
    public:
        std::vector<std::vector<int> > pathSum(TreeNode *root, int sum)
        {
            result_.clear();
            if(!root)
            {
                return result_;
            }
            
            currentPath_.clear();
            currentPath_.push_back(root->val);
            sum_ = sum;
            currentSum_ = root->val;
            
            FindPathSum(root);
            
            return result_;
        }
        
    private:
        
        void FindPathSum(TreeNode *node)
        {
            if(!node->left && !node->right)
            {
                if(currentSum_ == sum_)
                {
                    result_.push_back(currentPath_);
                }
                
                return;
            }
            
            if(node->left)
            {
                currentSum_ += node->left->val;
                currentPath_.push_back(node->left->val);
                FindPathSum(node->left);
                currentSum_ -= node->left->val;
                currentPath_.pop_back();
            }
            
            if(node->right)
            {
                currentSum_ += node->right->val;
                currentPath_.push_back(node->right->val);
                FindPathSum(node->right);
                currentSum_ -= node->right->val;
                currentPath_.pop_back();
            }
            
        }
        
        std::vector<std::vector<int> > result_;
        std::vector<int> currentPath_;
        int sum_;
        int currentSum_;
        
    };

提交后同样Judge Small和Judge Large双双通过。