路径总和题型整理

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum)
    {
        if (root == NULL) 
            return false;
        if (targetSum == root->val && root->left == NULL && root->right == NULL) return true;
        return hasPathSum(root->left, targetSum - root->val) || hasPathSum(root->right, targetSum - root->val);
    }
};

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum)
    {
        if (root == NULL) 
            return false;
        queue<pair<TreeNode*, int>> q;
        q.push({ root,root->val });
        while (!q.empty())
        {
            int sum = q.front().second;
            TreeNode* temp = q.front().first;
            q.pop();
            if (!temp->left && !temp->right)
            {
                if(sum==targetSum)
                return true;
                continue;
            }
            //同时朝着当前根节点的左右子树探索
            //探索的同时记录根节点到每个节点的路径和
            if (temp->left)
                q.push({ temp->left,temp->left->val + sum });
            if (temp->right)
                q.push({ temp->right,temp->right->val+sum });
        }
        return false;
    }
};

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum)
    {
        if (root == NULL) 
            return false;
        return backTravel(root,targetSum,root->val);
    }
    bool backTravel(TreeNode* root,int targetSum,int sum)
    {
        bool Lfind=false, Lright=false;
        if (!root) return false;
        if (!root->left && !root->right &&sum == targetSum)
            return true;
        if (root->left)
              Lfind=backTravel(root->left, targetSum, sum+root->left->val);
        if (root->right)
              Lright = backTravel(root->right, targetSum, sum+root->right->val);
        return Lfind || Lright;
    }
};

class Solution {
  public:
      vector<vector<int>> pathSum(TreeNode* root, int targetSum) 
      {
          vector<vector<int>> ret;
          if (root == NULL)
              return ret;
          vector<int> cur;
          backTrave(ret,cur,root, targetSum);
          return ret;
      }
      void backTrave(vector<vector<int>>& ret, vector<int>& cur, TreeNode* root, int targetSum)
      {
          if (root == NULL) return;
          if (root->left == NULL && root->right == NULL)
          {
              cur.push_back(root->val);
              if (accumulate(cur.begin(), cur.end(), 0) == targetSum)
                  ret.push_back(cur);
              //如果当前是找到了一个解，那么回溯，寻找其他可能解
              //如果当前节点是叶子节点，那么再往下找，也不会得到正确解，也需要回溯
              cur.pop_back();
              return;
          }
          else
          {
              cur.push_back(root->val);
              //先从左子树开始找，如果无法找到合适解，去右子树里面找
              //如果左子树里面找到了合适解，要去右子树里面找还有无其他合适解
              backTrave(ret, cur, root->left, targetSum);
              backTrave(ret, cur, root->right, targetSum);
              //如果当前左右子树都无法找到合适解，说明当前根的两个分支走不通，需要返回上一层，寻找别的路径走
              //那么进行回溯，来到上一层，走另一个分支，即如果当前根是上一层的左子树，那么回到上一层后需要到右子树里面寻找可能解
              cur.pop_back();
          }
      }
  };

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;

    void dfs(TreeNode* root, int sum) {
        if (root == nullptr) {
            return;
        }
        path.emplace_back(root->val);
        sum -= root->val;
        if (root->left == nullptr && root->right == nullptr && sum == 0) {
            ret.emplace_back(path);
        }
        dfs(root->left, sum);
        dfs(root->right, sum);
        path.pop_back();
    }

    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        dfs(root, sum);
        return ret;
    }
};

while queue 不空：
    cur = queue.pop()
    if cur 有效且未被访问过：
        进行处理
    for 节点 in cur 的所有相邻节点：
        if 该节点有效：
            queue.push(该节点)

level = 0
while queue 不空：
    size = queue.size()
    while (size --) {
        cur = queue.pop()
        if cur 有效且未被访问过：
            进行处理
        for 节点 in cur的所有相邻节点：
            if 该节点有效：
                queue.push(该节点)
    }
    level ++;

class Solution {
public:
    vector<vector<int>> ret;
    unordered_map<TreeNode*, TreeNode*> parent;

    void getPath(TreeNode* node) {
        vector<int> tmp;
        while (node != nullptr) {
            tmp.emplace_back(node->val);
            node = parent[node];
        }
        reverse(tmp.begin(), tmp.end());
        ret.emplace_back(tmp);
    }

    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        if (root == nullptr) {
            return ret;
        }

        queue<TreeNode*> que_node;
        queue<int> que_sum;
        que_node.emplace(root);
        que_sum.emplace(0);

        while (!que_node.empty()) {
            TreeNode* node = que_node.front();
            que_node.pop();
            int rec = que_sum.front() + node->val;
            que_sum.pop();

            if (node->left == nullptr && node->right == nullptr) {
                if (rec == sum) {
                    getPath(node);
                }
            } else {
                if (node->left != nullptr) {
                    parent[node->left] = node;
                    que_node.emplace(node->left);
                    que_sum.emplace(rec);
                }
                if (node->right != nullptr) {
                    parent[node->right] = node;
                    que_node.emplace(node->right);
                    que_sum.emplace(rec);
                }
            }
        }

        return ret;
    }
};