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 cafe9ec

Browse files
committed
feat: add solutions to lc problem: No.1273
No.1273.Delete Tree Nodes
1 parent 6f556d1 commit cafe9ec

File tree

8 files changed

+326
-4
lines changed

8 files changed

+326
-4
lines changed

‎solution/0700-0799/0742.Closest Leaf in a Binary Tree/README.md‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -74,7 +74,9 @@ root = [1,2,3,4,null,null,null,5,null,6], k = 2
7474

7575
<!-- 这里可写通用的实现逻辑 -->
7676

77-
DFS。
77+
DFS 和 BFS。
78+
79+
先通过 DFS 构建图,然后 BFS 找距离值为 k 的结点最近的叶子结点。
7880

7981
<!-- tabs:start -->
8082

‎solution/0700-0799/0742.Closest Leaf in a Binary Tree/README_EN.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -120,7 +120,7 @@ Diagram of binary tree:
120120

121121
## Solutions
122122

123-
DFS.
123+
DFS & BFS.
124124

125125
<!-- tabs:start -->
126126

‎solution/1200-1299/1273.Delete Tree Nodes/README.md‎

Lines changed: 113 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -64,22 +64,134 @@
6464

6565
<!-- 这里可写通用的实现逻辑 -->
6666

67+
先构建图。
68+
69+
然后对于树中的每一个节点 u,我们通过深度优先搜索的方法,递归地搜索它的所有子节点 v,计算出以 v 为根的子树的节点数目和权值之和。在这之后,我们将子节点的值分别进行累加,就可以得到以 u 为根的子树的节点数目和权值之和。如果权值之和为零,那么以 u 为根的子树需要被删除,我们将其节点数目也置为零,作为结果返回到上一层。最终根节点 0 对应的节点数目即为答案。
70+
6771
<!-- tabs:start -->
6872

6973
### **Python3**
7074

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

7377
```python
74-
78+
class Solution:
79+
def deleteTreeNodes(self, nodes: int, parent: List[int], value: List[int]) -> int:
80+
def dfs(u):
81+
for v in g[u]:
82+
dfs(v)
83+
value[u] += value[v]
84+
counter[u] += counter[v]
85+
if value[u] == 0:
86+
counter[u] = 0
87+
88+
g = defaultdict(list)
89+
for i, p in enumerate(parent):
90+
if p != -1:
91+
g[p].append(i)
92+
counter = [1] * nodes
93+
dfs(0)
94+
return counter[0]
7595
```
7696

7797
### **Java**
7898

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

81101
```java
102+
class Solution {
103+
private Map<Integer, List<Integer>> g;
104+
private int[] counter;
105+
private int[] value;
106+
107+
public int deleteTreeNodes(int nodes, int[] parent, int[] value) {
108+
g = new HashMap<>();
109+
for (int i = 0; i < nodes; ++i) {
110+
if (parent[i] != -1) {
111+
g.computeIfAbsent(parent[i], k -> new ArrayList<>()).add(i);
112+
}
113+
}
114+
this.value = value;
115+
counter = new int[nodes];
116+
Arrays.fill(counter, 1);
117+
dfs(0);
118+
return counter[0];
119+
}
120+
121+
private void dfs(int u) {
122+
for (int v : g.getOrDefault(u, Collections.emptyList())) {
123+
dfs(v);
124+
value[u] += value[v];
125+
counter[u] += counter[v];
126+
}
127+
if (value[u] == 0) {
128+
counter[u] = 0;
129+
}
130+
}
131+
}
132+
```
133+
134+
### **C++**
135+
136+
```cpp
137+
class Solution {
138+
public:
139+
unordered_map<int, vector<int>> g;
140+
vector<int> counter;
141+
vector<int> value;
142+
143+
int deleteTreeNodes(int nodes, vector<int>& parent, vector<int>& value) {
144+
for (int i = 0; i < nodes; ++i)
145+
if (parent[i] != -1)
146+
g[parent[i]].push_back(i);
147+
counter.resize(nodes, 1);
148+
this->value = value;
149+
dfs(0);
150+
return counter[0];
151+
}
152+
153+
void dfs(int u) {
154+
for (int v : g[u])
155+
{
156+
dfs(v);
157+
value[u] += value[v];
158+
counter[u] += counter[v];
159+
}
160+
if (value[u] == 0) counter[u] = 0;
161+
}
162+
};
163+
```
82164
165+
### **Go**
166+
167+
```go
168+
func deleteTreeNodes(nodes int, parent []int, value []int) int {
169+
g := make(map[int][]int)
170+
for i, p := range parent {
171+
if p != -1 {
172+
g[p] = append(g[p], i)
173+
}
174+
}
175+
counter := make([]int, nodes)
176+
for i := range counter {
177+
counter[i] = 1
178+
}
179+
var dfs func(u int)
180+
dfs = func(u int) {
181+
if vs, ok := g[u]; ok {
182+
for _, v := range vs {
183+
dfs(v)
184+
value[u] += value[v]
185+
counter[u] += counter[v]
186+
}
187+
}
188+
if value[u] == 0 {
189+
counter[u] = 0
190+
}
191+
}
192+
dfs(0)
193+
return counter[0]
194+
}
83195
```
84196

85197
### **...**

‎solution/1200-1299/1273.Delete Tree Nodes/README_EN.md‎

Lines changed: 109 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -65,13 +65,121 @@
6565
### **Python3**
6666

6767
```python
68-
68+
class Solution:
69+
def deleteTreeNodes(self, nodes: int, parent: List[int], value: List[int]) -> int:
70+
def dfs(u):
71+
for v in g[u]:
72+
dfs(v)
73+
value[u] += value[v]
74+
counter[u] += counter[v]
75+
if value[u] == 0:
76+
counter[u] = 0
77+
78+
g = defaultdict(list)
79+
for i, p in enumerate(parent):
80+
if p != -1:
81+
g[p].append(i)
82+
counter = [1] * nodes
83+
dfs(0)
84+
return counter[0]
6985
```
7086

7187
### **Java**
7288

7389
```java
90+
class Solution {
91+
private Map<Integer, List<Integer>> g;
92+
private int[] counter;
93+
private int[] value;
94+
95+
public int deleteTreeNodes(int nodes, int[] parent, int[] value) {
96+
g = new HashMap<>();
97+
for (int i = 0; i < nodes; ++i) {
98+
if (parent[i] != -1) {
99+
g.computeIfAbsent(parent[i], k -> new ArrayList<>()).add(i);
100+
}
101+
}
102+
this.value = value;
103+
counter = new int[nodes];
104+
Arrays.fill(counter, 1);
105+
dfs(0);
106+
return counter[0];
107+
}
108+
109+
private void dfs(int u) {
110+
for (int v : g.getOrDefault(u, Collections.emptyList())) {
111+
dfs(v);
112+
value[u] += value[v];
113+
counter[u] += counter[v];
114+
}
115+
if (value[u] == 0) {
116+
counter[u] = 0;
117+
}
118+
}
119+
}
120+
```
121+
122+
### **C++**
123+
124+
```cpp
125+
class Solution {
126+
public:
127+
unordered_map<int, vector<int>> g;
128+
vector<int> counter;
129+
vector<int> value;
130+
131+
int deleteTreeNodes(int nodes, vector<int>& parent, vector<int>& value) {
132+
for (int i = 0; i < nodes; ++i)
133+
if (parent[i] != -1)
134+
g[parent[i]].push_back(i);
135+
counter.resize(nodes, 1);
136+
this->value = value;
137+
dfs(0);
138+
return counter[0];
139+
}
140+
141+
void dfs(int u) {
142+
for (int v : g[u])
143+
{
144+
dfs(v);
145+
value[u] += value[v];
146+
counter[u] += counter[v];
147+
}
148+
if (value[u] == 0) counter[u] = 0;
149+
}
150+
};
151+
```
74152
153+
### **Go**
154+
155+
```go
156+
func deleteTreeNodes(nodes int, parent []int, value []int) int {
157+
g := make(map[int][]int)
158+
for i, p := range parent {
159+
if p != -1 {
160+
g[p] = append(g[p], i)
161+
}
162+
}
163+
counter := make([]int, nodes)
164+
for i := range counter {
165+
counter[i] = 1
166+
}
167+
var dfs func(u int)
168+
dfs = func(u int) {
169+
if vs, ok := g[u]; ok {
170+
for _, v := range vs {
171+
dfs(v)
172+
value[u] += value[v]
173+
counter[u] += counter[v]
174+
}
175+
}
176+
if value[u] == 0 {
177+
counter[u] = 0
178+
}
179+
}
180+
dfs(0)
181+
return counter[0]
182+
}
75183
```
76184

77185
### **...**
Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
unordered_map<int, vector<int>> g;
4+
vector<int> counter;
5+
vector<int> value;
6+
7+
int deleteTreeNodes(int nodes, vector<int>& parent, vector<int>& value) {
8+
for (int i = 0; i < nodes; ++i)
9+
if (parent[i] != -1)
10+
g[parent[i]].push_back(i);
11+
counter.resize(nodes, 1);
12+
this->value = value;
13+
dfs(0);
14+
return counter[0];
15+
}
16+
17+
void dfs(int u) {
18+
for (int v : g[u])
19+
{
20+
dfs(v);
21+
value[u] += value[v];
22+
counter[u] += counter[v];
23+
}
24+
if (value[u] == 0) counter[u] = 0;
25+
}
26+
};
Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
func deleteTreeNodes(nodes int, parent []int, value []int) int {
2+
g := make(map[int][]int)
3+
for i, p := range parent {
4+
if p != -1 {
5+
g[p] = append(g[p], i)
6+
}
7+
}
8+
counter := make([]int, nodes)
9+
for i := range counter {
10+
counter[i] = 1
11+
}
12+
var dfs func(u int)
13+
dfs = func(u int) {
14+
if vs, ok := g[u]; ok {
15+
for _, v := range vs {
16+
dfs(v)
17+
value[u] += value[v]
18+
counter[u] += counter[v]
19+
}
20+
}
21+
if value[u] == 0 {
22+
counter[u] = 0
23+
}
24+
}
25+
dfs(0)
26+
return counter[0]
27+
}
Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
class Solution {
2+
private Map<Integer, List<Integer>> g;
3+
private int[] counter;
4+
private int[] value;
5+
6+
public int deleteTreeNodes(int nodes, int[] parent, int[] value) {
7+
g = new HashMap<>();
8+
for (int i = 0; i < nodes; ++i) {
9+
if (parent[i] != -1) {
10+
g.computeIfAbsent(parent[i], k -> new ArrayList<>()).add(i);
11+
}
12+
}
13+
this.value = value;
14+
counter = new int[nodes];
15+
Arrays.fill(counter, 1);
16+
dfs(0);
17+
return counter[0];
18+
}
19+
20+
private void dfs(int u) {
21+
for (int v : g.getOrDefault(u, Collections.emptyList())) {
22+
dfs(v);
23+
value[u] += value[v];
24+
counter[u] += counter[v];
25+
}
26+
if (value[u] == 0) {
27+
counter[u] = 0;
28+
}
29+
}
30+
}
Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution:
2+
def deleteTreeNodes(self, nodes: int, parent: List[int], value: List[int]) -> int:
3+
def dfs(u):
4+
for v in g[u]:
5+
dfs(v)
6+
value[u] += value[v]
7+
counter[u] += counter[v]
8+
if value[u] == 0:
9+
counter[u] = 0
10+
11+
g = defaultdict(list)
12+
for i, p in enumerate(parent):
13+
if p != -1:
14+
g[p].append(i)
15+
counter = [1] * nodes
16+
dfs(0)
17+
return counter[0]

0 commit comments

Comments
(0)

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