Skip to content

Commit f8b04de

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1273
No.1273.Delete Tree Nodes
1 parent 93ba8e9 commit f8b04de

File tree

7 files changed

+184
-217
lines changed

7 files changed

+184
-217
lines changed

‎solution/1200-1299/1272.Remove Interval/README.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -55,8 +55,8 @@
5555
我们记要删除的区间为 $[x, y)$，遍历区间列表，对于每个区间 $[a, b)$，有以下三种情况：
5656

5757
- $a \geq y$ 或 $b \leq x$，表示该区间与要删除的区间没有交集，直接将该区间加入答案；
58-
- $a \lt x$，$b \gt y$，表示该区间与要删除的区间有交集，将该区间分成两个区间加入答案；
59-
- $a \geq x$，$b \leq y$，表示该区间被要删除的区间完全覆盖，不加入答案。
58+
- $a \lt x$, $b \gt y$，表示该区间与要删除的区间有交集，将该区间分成两个区间加入答案；
59+
- $a \geq x$, $b \leq y$，表示该区间被要删除的区间完全覆盖，不加入答案。
6060

6161
时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为区间列表的长度。
6262

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

+66-73
Original file line numberDiff line numberDiff line change
@@ -64,9 +64,15 @@
6464

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

67-
先构建图。
67+
**方法一：DFS**
6868

69-
然后对于树中的每一个节点 u，我们通过深度优先搜索的方法，递归地搜索它的所有子节点 v，计算出以 v 为根的子树的节点数目和权值之和。在这之后，我们将子节点的值分别进行累加，就可以得到以 u 为根的子树的节点数目和权值之和。如果权值之和为零，那么以 u 为根的子树需要被删除，我们将其节点数目也置为零，作为结果返回到上一层。最终根节点 0 对应的节点数目即为答案。
69+
我们先将树转换成图 $g$，其中 $g[i]$ 表示节点 $i$ 的所有子节点。
70+
71+
然后我们设计一个函数 $dfs(i)$，表示以节点 $i$ 为根的子树的节点数目和权值之和。那么答案就是 $dfs(0)[1]$。
72+
73+
在这个函数中，我们递归地计算出以每个子节点 $j$ 为根的子树的节点数目和权值之和，然后将这些值进行累加，如果累加后的值为零，那么我们就将这个子树的节点数目置为零。最后我们返回以节点 $i$ 为根的子树的节点数目和权值之和。
74+
75+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是树的节点数目。
7076

7177
<!-- tabs:start -->
7278

@@ -77,21 +83,20 @@
7783
```python
7884
class Solution:
7985
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
86+
def dfs(i):
87+
s, m = value[i], 1
88+
for j in g[i]:
89+
t, n = dfs(j)
90+
s += t
91+
m += n
92+
if s == 0:
93+
m = 0
94+
return (s, m)
8795

8896
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]
97+
for i in range(1, nodes):
98+
g[parent[i]].append(i)
99+
return dfs(0)[1]
95100
```
96101

97102
### **Java**
@@ -100,33 +105,30 @@ class Solution:
100105

101106
```java
102107
class Solution {
103-
private Map<Integer, List<Integer>> g;
104-
private int[] counter;
108+
private List<Integer>[] g;
105109
private int[] value;
106110

107111
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-
}
112+
g = new List[nodes];
113+
Arrays.setAll(g, k -> new ArrayList<>());
114+
for (int i = 1; i < nodes; ++i) {
115+
g[parent[i]].add(i);
113116
}
114117
this.value = value;
115-
counter = new int[nodes];
116-
Arrays.fill(counter, 1);
117-
dfs(0);
118-
return counter[0];
118+
return dfs(0)[1];
119119
}
120120

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];
121+
private int[] dfs(int i) {
122+
int[] res = new int[] {value[i], 1};
123+
for (int j : g[i]) {
124+
int[] t = dfs(j);
125+
res[0] += t[0];
126+
res[1] += t[1];
126127
}
127-
if (value[u] == 0) {
128-
counter[u] = 0;
128+
if (res[0] == 0) {
129+
res[1] = 0;
129130
}
131+
return res;
130132
}
131133
}
132134
```
@@ -136,27 +138,24 @@ class Solution {
136138
```cpp
137139
class Solution {
138140
public:
139-
unordered_map<int, vector<int>> g;
140-
vector<int> counter;
141-
vector<int> value;
142-
143141
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-
dfs(v);
156-
value[u] += value[v];
157-
counter[u] += counter[v];
142+
vector<vector<int>> g(nodes);
143+
for (int i = 1; i < nodes; ++i) {
144+
g[parent[i]].emplace_back(i);
158145
}
159-
if (value[u] == 0) counter[u] = 0;
146+
function<pair<int, int>(int)> dfs = [&](int i) -> pair<int, int> {
147+
int s = value[i], m = 1;
148+
for (int j : g[i]) {
149+
auto [t, n] = dfs(j);
150+
s += t;
151+
m += n;
152+
}
153+
if (s == 0) {
154+
m = 0;
155+
}
156+
return pair<int, int>{s, m};
157+
};
158+
return dfs(0).second;
160159
}
161160
};
162161
```
@@ -165,31 +164,25 @@ public:
165164
166165
```go
167166
func deleteTreeNodes(nodes int, parent []int, value []int) int {
168-
g := make(map[int][]int)
169-
for i, p := range parent {
170-
if p != -1 {
171-
g[p] = append(g[p], i)
172-
}
173-
}
174-
counter := make([]int, nodes)
175-
for i := range counter {
176-
counter[i] = 1
167+
g := make([][]int, nodes)
168+
for i := 1; i < nodes; i++ {
169+
g[parent[i]] = append(g[parent[i]], i)
177170
}
178-
var dfs func(u int)
179-
dfs = func(u int) {
180-
if vs, ok := g[u]; ok {
181-
for _, v := range vs {
182-
dfs(v)
183-
value[u] += value[v]
184-
counter[u] += counter[v]
185-
}
171+
type pair struct{ s, n int }
172+
var dfs func(int) pair
173+
dfs = func(i int) pair {
174+
s, m := value[i], 1
175+
for _, j := range g[i] {
176+
t := dfs(j)
177+
s += t.s
178+
m += t.n
186179
}
187-
if value[u] == 0 {
188-
counter[u] = 0
180+
if s == 0 {
181+
m = 0
189182
}
183+
return pair{s, m}
190184
}
191-
dfs(0)
192-
return counter[0]
185+
return dfs(0).n
193186
}
194187
```
195188

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

+58-71
Original file line numberDiff line numberDiff line change
@@ -53,54 +53,50 @@
5353
```python
5454
class Solution:
5555
def deleteTreeNodes(self, nodes: int, parent: List[int], value: List[int]) -> int:
56-
def dfs(u):
57-
for v in g[u]:
58-
dfs(v)
59-
value[u] += value[v]
60-
counter[u] += counter[v]
61-
if value[u] == 0:
62-
counter[u] = 0
56+
def dfs(i):
57+
s, m = value[i], 1
58+
for j in g[i]:
59+
t, n = dfs(j)
60+
s += t
61+
m += n
62+
if s == 0:
63+
m = 0
64+
return (s, m)
6365

6466
g = defaultdict(list)
65-
for i, p in enumerate(parent):
66-
if p != -1:
67-
g[p].append(i)
68-
counter = [1] * nodes
69-
dfs(0)
70-
return counter[0]
67+
for i in range(1, nodes):
68+
g[parent[i]].append(i)
69+
return dfs(0)[1]
7170
```
7271

7372
### **Java**
7473

7574
```java
7675
class Solution {
77-
private Map<Integer, List<Integer>> g;
78-
private int[] counter;
76+
private List<Integer>[] g;
7977
private int[] value;
8078

8179
public int deleteTreeNodes(int nodes, int[] parent, int[] value) {
82-
g = new HashMap<>();
83-
for (int i = 0; i < nodes; ++i) {
84-
if (parent[i] != -1) {
85-
g.computeIfAbsent(parent[i], k -> new ArrayList<>()).add(i);
86-
}
80+
g = new List[nodes];
81+
Arrays.setAll(g, k -> new ArrayList<>());
82+
for (int i = 1; i < nodes; ++i) {
83+
g[parent[i]].add(i);
8784
}
8885
this.value = value;
89-
counter = new int[nodes];
90-
Arrays.fill(counter, 1);
91-
dfs(0);
92-
return counter[0];
86+
return dfs(0)[1];
9387
}
9488

95-
private void dfs(int u) {
96-
for (int v : g.getOrDefault(u, Collections.emptyList())) {
97-
dfs(v);
98-
value[u] += value[v];
99-
counter[u] += counter[v];
89+
private int[] dfs(int i) {
90+
int[] res = new int[] {value[i], 1};
91+
for (int j : g[i]) {
92+
int[] t = dfs(j);
93+
res[0] += t[0];
94+
res[1] += t[1];
10095
}
101-
if (value[u] == 0) {
102-
counter[u] = 0;
96+
if (res[0] == 0) {
97+
res[1] = 0;
10398
}
99+
return res;
104100
}
105101
}
106102
```
@@ -110,27 +106,24 @@ class Solution {
110106
```cpp
111107
class Solution {
112108
public:
113-
unordered_map<int, vector<int>> g;
114-
vector<int> counter;
115-
vector<int> value;
116-
117109
int deleteTreeNodes(int nodes, vector<int>& parent, vector<int>& value) {
118-
for (int i = 0; i < nodes; ++i)
119-
if (parent[i] != -1)
120-
g[parent[i]].push_back(i);
121-
counter.resize(nodes, 1);
122-
this->value = value;
123-
dfs(0);
124-
return counter[0];
125-
}
126-
127-
void dfs(int u) {
128-
for (int v : g[u]) {
129-
dfs(v);
130-
value[u] += value[v];
131-
counter[u] += counter[v];
110+
vector<vector<int>> g(nodes);
111+
for (int i = 1; i < nodes; ++i) {
112+
g[parent[i]].emplace_back(i);
132113
}
133-
if (value[u] == 0) counter[u] = 0;
114+
function<pair<int, int>(int)> dfs = [&](int i) -> pair<int, int> {
115+
int s = value[i], m = 1;
116+
for (int j : g[i]) {
117+
auto [t, n] = dfs(j);
118+
s += t;
119+
m += n;
120+
}
121+
if (s == 0) {
122+
m = 0;
123+
}
124+
return pair<int, int>{s, m};
125+
};
126+
return dfs(0).second;
134127
}
135128
};
136129
```
@@ -139,31 +132,25 @@ public:
139132
140133
```go
141134
func deleteTreeNodes(nodes int, parent []int, value []int) int {
142-
g := make(map[int][]int)
143-
for i, p := range parent {
144-
if p != -1 {
145-
g[p] = append(g[p], i)
146-
}
147-
}
148-
counter := make([]int, nodes)
149-
for i := range counter {
150-
counter[i] = 1
135+
g := make([][]int, nodes)
136+
for i := 1; i < nodes; i++ {
137+
g[parent[i]] = append(g[parent[i]], i)
151138
}
152-
var dfs func(u int)
153-
dfs = func(u int) {
154-
if vs, ok := g[u]; ok {
155-
for _, v := range vs {
156-
dfs(v)
157-
value[u] += value[v]
158-
counter[u] += counter[v]
159-
}
139+
type pair struct{ s, n int }
140+
var dfs func(int) pair
141+
dfs = func(i int) pair {
142+
s, m := value[i], 1
143+
for _, j := range g[i] {
144+
t := dfs(j)
145+
s += t.s
146+
m += t.n
160147
}
161-
if value[u] == 0 {
162-
counter[u] = 0
148+
if s == 0 {
149+
m = 0
163150
}
151+
return pair{s, m}
164152
}
165-
dfs(0)
166-
return counter[0]
153+
return dfs(0).n
167154
}
168155
```
169156

0 commit comments

Comments
 (0)