[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_[].clear();
             treeLevel_[].clear();

             bool flag = false;
             treeLevel_[].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_[];
     };

hasPathSum

提交后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_;

     };

pathSum

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