Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 3cc89b5

Browse files
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
### **...**
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+
};
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)

AltStyle によって変換されたページ (->オリジナル) /