LeetCode-剑指34-二叉树中和为某一值的路径

1、深度遍历+回溯

我们可以通过深度遍历遍历树中的每一个节点，在遍历过一个节点之后我们将当前节点加入temp_res中。若此时该节点为叶子节点且减去该节点之后target为0说明这就是我们要找的路径，我们将当前路径加入res中。在遍历完当前节点之后，我们遍历该节点的左子节点或右子节点。最后我们将当前节点从temp_res中删除表示回溯过程。

class Solution {
public:
    vector<vector<int>> res;
    vector<int> temp_res;

    void dfs(TreeNode *root, int target) {
        temp_res.emplace_back(root->val);
        if (root->left == nullptr && root->right == nullptr && target - root->val == 0) {
            res.emplace_back(temp_res);
        }
        if (root->left) dfs(root->left, target - root->val);
        if (root->right) dfs(root->right, target - root->val);
        temp_res.pop_back();
    }

    vector<vector<int>> pathSum(TreeNode *root, int target) {
        if (!root) return {};
        dfs(root, target);
        return res;
    }
};

2、广度遍历

我们还可以广度优先遍历整棵树，当我们遍历到叶子节点时我们比较当前的总和是否等于target，若是我们则利用记录了每个节点父节点的哈希表来查找路径中的上一个节点。

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 target) {
        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 == target) {
                    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;
    }
};