Skip to content

Commit 3cc89b5

Browse files
maolonglongmaolonglong
committed
feat: add solutions to lc problem: No.0437.Path Sum III
1 parent 24a7a6f commit 3cc89b5

File tree

6 files changed

+406
-24
lines changed

6 files changed

+406
-24
lines changed

‎solution/0400-0499/0437.Path Sum III/README.md

Lines changed: 144 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,22 +38,165 @@
3838

3939
<!-- 这里可写通用的实现逻辑 -->
4040

41+
在遍历的过程中，记录当前路径上的前缀和
42+
4143
<!-- tabs:start -->
4244

4345
### **Python3**
4446

4547
<!-- 这里可写当前语言的特殊实现逻辑 -->
4648

4749
```python
48-
50+
# Definition for a binary tree node.
51+
# class TreeNode:
52+
# def __init__(self, val=0, left=None, right=None):
53+
# self.val = val
54+
# self.left = left
55+
# self.right = right
56+
class Solution:
57+
def pathSum(self, root: TreeNode, targetSum: int) -> int:
58+
preSum = defaultdict(int)
59+
preSum[0] = 1
60+
61+
def dfs(node: TreeNode, cur: int) -> int:
62+
if not node:
63+
return 0
64+
65+
cur += node.val
66+
ret = preSum[cur - targetSum]
67+
68+
preSum[cur] += 1
69+
ret += dfs(node.left, cur)
70+
ret += dfs(node.right, cur)
71+
preSum[cur] -= 1
72+
73+
return ret
74+
75+
return dfs(root, 0)
4976
```
5077

5178
### **Java**
5279

5380
<!-- 这里可写当前语言的特殊实现逻辑 -->
5481

5582
```java
83+
/**
84+
* Definition for a binary tree node.
85+
* public class TreeNode {
86+
* int val;
87+
* TreeNode left;
88+
* TreeNode right;
89+
* TreeNode() {}
90+
* TreeNode(int val) { this.val = val; }
91+
* TreeNode(int val, TreeNode left, TreeNode right) {
92+
* this.val = val;
93+
* this.left = left;
94+
* this.right = right;
95+
* }
96+
* }
97+
*/
98+
class Solution {
99+
100+
private final Map<Integer, Integer> preSum = new HashMap<>();
101+
102+
public int pathSum(TreeNode root, int targetSum) {
103+
preSum.put(0, 1);
104+
return dfs(root, 0, targetSum);
105+
}
106+
107+
private int dfs(TreeNode node, int cur, int targetSum) {
108+
if (node == null) {
109+
return 0;
110+
}
111+
112+
cur += node.val;
113+
int ret = preSum.getOrDefault(cur - targetSum, 0);
114+
115+
preSum.merge(cur, 1, Integer::sum);
116+
ret += dfs(node.left, cur, targetSum);
117+
ret += dfs(node.right, cur, targetSum);
118+
preSum.merge(cur, -1, Integer::sum);
119+
120+
return ret;
121+
}
122+
}
123+
```
124+
125+
### **Go**
126+
127+
```go
128+
/**
129+
* Definition for a binary tree node.
130+
* type TreeNode struct {
131+
* Val int
132+
* Left *TreeNode
133+
* Right *TreeNode
134+
* }
135+
*/
136+
func pathSum(root *TreeNode, targetSum int) int {
137+
preSum := make(map[int]int)
138+
preSum[0] = 1
139+
140+
var dfs func(*TreeNode, int) int
141+
dfs = func(node *TreeNode, cur int) int {
142+
if node == nil {
143+
return 0
144+
}
145+
146+
cur += node.Val
147+
ret := preSum[cur-targetSum]
148+
149+
preSum[cur]++
150+
ret += dfs(node.Left, cur)
151+
ret += dfs(node.Right, cur)
152+
preSum[cur]--
153+
154+
return ret
155+
}
156+
157+
return dfs(root, 0)
158+
}
159+
```
56160

161+
### **C++**
162+
163+
```cpp
164+
/**
165+
* Definition for a binary tree node.
166+
* struct TreeNode {
167+
* int val;
168+
* TreeNode *left;
169+
* TreeNode *right;
170+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
171+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
172+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
173+
* };
174+
*/
175+
class Solution {
176+
public:
177+
int pathSum(TreeNode* root, int targetSum) {
178+
unordered_map<int, int> preSum;
179+
preSum[0] = 1;
180+
181+
function<int(TreeNode*, int)> dfs = [&](TreeNode* node, int cur) {
182+
if (node == nullptr) {
183+
return 0;
184+
}
185+
186+
cur += node->val;
187+
int ret = preSum[cur - targetSum];
188+
189+
++preSum[cur];
190+
ret += dfs(node->left, cur);
191+
ret += dfs(node->right, cur);
192+
--preSum[cur];
193+
194+
return ret;
195+
};
196+
197+
return dfs(root, 0);
198+
}
199+
};
57200
```
58201

59202
### **...**

‎solution/0400-0499/0437.Path Sum III/README_EN.md

Lines changed: 142 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -41,13 +41,154 @@
4141
### **Python3**
4242

4343
```python
44-
44+
# Definition for a binary tree node.
45+
# class TreeNode:
46+
# def __init__(self, val=0, left=None, right=None):
47+
# self.val = val
48+
# self.left = left
49+
# self.right = right
50+
class Solution:
51+
def pathSum(self, root: TreeNode, targetSum: int) -> int:
52+
preSum = defaultdict(int)
53+
preSum[0] = 1
54+
55+
def dfs(node: TreeNode, cur: int) -> int:
56+
if not node:
57+
return 0
58+
59+
cur += node.val
60+
ret = preSum[cur - targetSum]
61+
62+
preSum[cur] += 1
63+
ret += dfs(node.left, cur)
64+
ret += dfs(node.right, cur)
65+
preSum[cur] -= 1
66+
67+
return ret
68+
69+
return dfs(root, 0)
4570
```
4671

4772
### **Java**
4873

4974
```java
75+
/**
76+
* Definition for a binary tree node.
77+
* public class TreeNode {
78+
* int val;
79+
* TreeNode left;
80+
* TreeNode right;
81+
* TreeNode() {}
82+
* TreeNode(int val) { this.val = val; }
83+
* TreeNode(int val, TreeNode left, TreeNode right) {
84+
* this.val = val;
85+
* this.left = left;
86+
* this.right = right;
87+
* }
88+
* }
89+
*/
90+
class Solution {
91+
92+
private final Map<Integer, Integer> preSum = new HashMap<>();
93+
94+
public int pathSum(TreeNode root, int targetSum) {
95+
preSum.put(0, 1);
96+
return dfs(root, 0, targetSum);
97+
}
98+
99+
private int dfs(TreeNode node, int cur, int targetSum) {
100+
if (node == null) {
101+
return 0;
102+
}
103+
104+
cur += node.val;
105+
int ret = preSum.getOrDefault(cur - targetSum, 0);
106+
107+
preSum.merge(cur, 1, Integer::sum);
108+
ret += dfs(node.left, cur, targetSum);
109+
ret += dfs(node.right, cur, targetSum);
110+
preSum.merge(cur, -1, Integer::sum);
111+
112+
return ret;
113+
}
114+
}
115+
```
116+
117+
### **Go**
118+
119+
```go
120+
/**
121+
* Definition for a binary tree node.
122+
* type TreeNode struct {
123+
* Val int
124+
* Left *TreeNode
125+
* Right *TreeNode
126+
* }
127+
*/
128+
func pathSum(root *TreeNode, targetSum int) int {
129+
preSum := make(map[int]int)
130+
preSum[0] = 1
131+
132+
var dfs func(*TreeNode, int) int
133+
dfs = func(node *TreeNode, cur int) int {
134+
if node == nil {
135+
return 0
136+
}
137+
138+
cur += node.Val
139+
ret := preSum[cur-targetSum]
140+
141+
preSum[cur]++
142+
ret += dfs(node.Left, cur)
143+
ret += dfs(node.Right, cur)
144+
preSum[cur]--
145+
146+
return ret
147+
}
148+
149+
return dfs(root, 0)
150+
}
151+
```
50152

153+
### **C++**
154+
155+
```cpp
156+
/**
157+
* Definition for a binary tree node.
158+
* struct TreeNode {
159+
* int val;
160+
* TreeNode *left;
161+
* TreeNode *right;
162+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
163+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
164+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
165+
* };
166+
*/
167+
class Solution {
168+
public:
169+
int pathSum(TreeNode* root, int targetSum) {
170+
unordered_map<int, int> preSum;
171+
preSum[0] = 1;
172+
173+
function<int(TreeNode*, int)> dfs = [&](TreeNode* node, int cur) {
174+
if (node == nullptr) {
175+
return 0;
176+
}
177+
178+
cur += node->val;
179+
int ret = preSum[cur - targetSum];
180+
181+
++preSum[cur];
182+
ret += dfs(node->left, cur);
183+
ret += dfs(node->right, cur);
184+
--preSum[cur];
185+
186+
return ret;
187+
};
188+
189+
return dfs(root, 0);
190+
}
191+
};
51192
```
52193

53194
### **...**

‎solution/0400-0499/0437.Path Sum III/Solution.cpp

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
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+
int pathSum(TreeNode* root, int targetSum) {
15+
unordered_map<int, int> preSum;
16+
preSum[0] = 1;
17+
18+
function<int(TreeNode*, int)> dfs = [&](TreeNode* node, int cur) {
19+
if (node == nullptr) {
20+
return 0;
21+
}
22+
23+
cur += node->val;
24+
int ret = preSum[cur - targetSum];
25+
26+
++preSum[cur];
27+
ret += dfs(node->left, cur);
28+
ret += dfs(node->right, cur);
29+
--preSum[cur];
30+
31+
return ret;
32+
};
33+
34+
return dfs(root, 0);
35+
}
36+
};

‎solution/0400-0499/0437.Path Sum III/Solution.go

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* type TreeNode struct {
4+
* Val int
5+
* Left *TreeNode
6+
* Right *TreeNode
7+
* }
8+
*/
9+
func pathSum(root *TreeNode, targetSum int) int {
10+
preSum := make(map[int]int)
11+
preSum[0] = 1
12+
13+
var dfs func(*TreeNode, int) int
14+
dfs = func(node *TreeNode, cur int) int {
15+
if node == nil {
16+
return 0
17+
}
18+
19+
cur += node.Val
20+
ret := preSum[cur-targetSum]
21+
22+
preSum[cur]++
23+
ret += dfs(node.Left, cur)
24+
ret += dfs(node.Right, cur)
25+
preSum[cur]--
26+
27+
return ret
28+
}
29+
30+
return dfs(root, 0)
31+
}

0 commit comments

Comments
 (0)