113. 路径总和 II

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。

叶子节点是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：[]

示例 3：

输入：root = [1,2], targetSum = 0
输出：[]

提示：

树中节点总数在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

BFS解法：

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     vector<vector<int>> answer;
15     unordered_map<TreeNode*, TreeNode*> hashMap; // key->子节点,Value->父节点
16     void getPath(TreeNode *node) {
17         vector<int> path;
18         while (node != nullptr) {
19             path.push_back(node->val);
20             node = hashMap[node]; // 指向当前节点的父节点
21         }
22         reverse(path.begin(), path.end());
23         answer.push_back(path);
24     }
25     vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
26         if (root == nullptr) {
27             return answer;
28         }
29         queue<TreeNode*> qNode; // 存储节点
30         queue<int> qSum; // 存储单条路径节点总和
31         qNode.push(root);
32         qSum.push(0);
33         while (!qNode.empty()) {
34             TreeNode *currentNode = qNode.front();
35             qNode.pop();
36             int tmpSum = qSum.front() + currentNode->val;
37             qSum.pop();
38             if (currentNode->left == nullptr && currentNode->right == nullptr) {
39                 if (tmpSum == targetSum) {
40                     getPath(currentNode);
41                 }
42                 continue;
43             }
44             if (currentNode->left != nullptr) {
45                 hashMap[currentNode->left] = currentNode; // 保存父子节点关系
46                 qNode.push(currentNode->left);
47                 qSum.push(tmpSum);
48             }
49             if (currentNode->right != nullptr) {
50                 hashMap[currentNode->right] = currentNode;
51                 qNode.push(currentNode->right);
52                 qSum.push(tmpSum);
53             }
54 
55         }
56         return answer;
57     }
58 };

DFS解法：

 1 #include <iostream>
 2 #include <vector>
 3 
 4 using namespace std;
 5 
 6 /**
 7     Definition for a binary tree node.
 8  */
 9 struct TreeNode {
10     int val;
11     TreeNode *left;
12     TreeNode *right;
13     TreeNode() : val(0), left(nullptr), right(nullptr) {}
14     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
15     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
16 };
17 
18 class Solution {
19 public:
20     void pathSumHelper(TreeNode *node, int sum, vector<int> path, vector<vector<int>> &answer) {
21         if (node == nullptr) {
22             return;
23         }
24         path.push_back(node->val);
25         sum -= node->val;
26         // 当到达叶子节点且剩余节点总和为0时,该路径符合条件
27         if (sum == 0 && node->left == nullptr && node->right == nullptr) {
28             answer.push_back(path);
29         }
30         pathSumHelper(node->left, sum, path, answer);
31         pathSumHelper(node->right, sum, path, answer);
32         return;
33     }
34     vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
35         vector<vector<int>> answer;
36         if (root == nullptr) {
37             return answer;
38         }
39         vector<int> path;
40         pathSumHelper(root, targetSum, path, answer);
41         return answer;
42     }
43 };
44 
45 int main()
46 {
47     TreeNode node1 = TreeNode(5);
48     TreeNode node2 = TreeNode(4);
49     TreeNode node3 = TreeNode(8);
50     TreeNode node4 = TreeNode(11);
51     TreeNode node5 = TreeNode(13);
52     TreeNode node6 = TreeNode(4);
53     TreeNode node7 = TreeNode(7);
54     TreeNode node8 = TreeNode(2);
55     TreeNode node9 = TreeNode(5);
56     TreeNode node10 = TreeNode(1);
57     node1.left = &node2;
58     node1.right = &node3;
59     node2.left = &node4;
60     node3.left = &node5;
61     node3.right = &node6;
62     node4.left = &node7;
63     node4.right = &node8;
64     node6.left = &node9;
65     node6.right = &node10;
66 
67     Solution *test = new Solution();
68     vector<vector<int>> answer;
69     int targetSum = 22;
70     answer = test->pathSum(&node1, targetSum);
71     for (const auto &vec : answer) {
72         for (const auto &val : vec) {
73             cout << val << " ";
74         }
75         cout << endl;
76     }
77     system("pause");
78     return 0;
79 }