Skip to content

Commit 808b753

Browse files
maolonglongmaolonglong
committed
feat: add solutions to lcof2 problem: No.050
1 parent 851fbb4 commit 808b753

File tree

5 files changed

+277
-1
lines changed

5 files changed

+277
-1
lines changed

‎lcof2/剑指 Offer II 050. 向下的路径节点之和/README.md‎

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

4747
<!-- 这里可写通用的实现逻辑 -->
4848

49+
在遍历的过程中，记录当前路径上的前缀和
50+
4951
<!-- tabs:start -->
5052

5153
### **Python3**
5254

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

5557
```python
56-
58+
# Definition for a binary tree node.
59+
# class TreeNode:
60+
# def __init__(self, val=0, left=None, right=None):
61+
# self.val = val
62+
# self.left = left
63+
# self.right = right
64+
class Solution:
65+
def pathSum(self, root: TreeNode, targetSum: int) -> int:
66+
preSum = defaultdict(int)
67+
preSum[0] = 1
68+
69+
def dfs(node: TreeNode, cur: int) -> int:
70+
if not node:
71+
return 0
72+
73+
cur += node.val
74+
ret = preSum[cur - targetSum]
75+
76+
preSum[cur] += 1
77+
ret += dfs(node.left, cur)
78+
ret += dfs(node.right, cur)
79+
preSum[cur] -= 1
80+
81+
return ret
82+
83+
return dfs(root, 0)
5784
```
5885

5986
### **Java**
6087

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

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

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

67210
### **...**

‎lcof2/剑指 Offer II 050. 向下的路径节点之和/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+
};

‎lcof2/剑指 Offer II 050. 向下的路径节点之和/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+
}

‎lcof2/剑指 Offer II 050. 向下的路径节点之和/Solution.java‎

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* public class TreeNode {
4+
* int val;
5+
* TreeNode left;
6+
* TreeNode right;
7+
* TreeNode() {}
8+
* TreeNode(int val) { this.val = val; }
9+
* TreeNode(int val, TreeNode left, TreeNode right) {
10+
* this.val = val;
11+
* this.left = left;
12+
* this.right = right;
13+
* }
14+
* }
15+
*/
16+
class Solution {
17+
18+
private final Map<Integer, Integer> preSum = new HashMap<>();
19+
20+
public int pathSum(TreeNode root, int targetSum) {
21+
preSum.put(0, 1);
22+
return dfs(root, 0, targetSum);
23+
}
24+
25+
private int dfs(TreeNode node, int cur, int targetSum) {
26+
if (node == null) {
27+
return 0;
28+
}
29+
30+
cur += node.val;
31+
int ret = preSum.getOrDefault(cur - targetSum, 0);
32+
33+
preSum.merge(cur, 1, Integer::sum);
34+
ret += dfs(node.left, cur, targetSum);
35+
ret += dfs(node.right, cur, targetSum);
36+
preSum.merge(cur, -1, Integer::sum);
37+
38+
return ret;
39+
}
40+
}

‎lcof2/剑指 Offer II 050. 向下的路径节点之和/Solution.py‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
# Definition for a binary tree node.
2+
# class TreeNode:
3+
# def __init__(self, val=0, left=None, right=None):
4+
# self.val = val
5+
# self.left = left
6+
# self.right = right
7+
class Solution:
8+
def pathSum(self, root: TreeNode, targetSum: int) -> int:
9+
preSum = defaultdict(int)
10+
preSum[0] = 1
11+
12+
def dfs(node: TreeNode, cur: int) -> int:
13+
if not node:
14+
return 0
15+
16+
cur += node.val
17+
ret = preSum[cur - targetSum]
18+
19+
preSum[cur] += 1
20+
ret += dfs(node.left, cur)
21+
ret += dfs(node.right, cur)
22+
preSum[cur] -= 1
23+
24+
return ret
25+
26+
return dfs(root, 0)

0 commit comments

Comments
 (0)