Skip to content

Commit ae484ea

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1361.Validate Binary Tree Nodes
1 parent d2e595d commit ae484ea

File tree

6 files changed

+486
-3
lines changed

6 files changed

+486
-3
lines changed

‎solution/1300-1399/1361.Validate Binary Tree Nodes/README.md

+209-2
Original file line numberDiff line numberDiff line change
@@ -58,27 +58,234 @@
5858
<li><code>-1 &lt;= leftChild[i], rightChild[i] &lt;= n - 1</code></li>
5959
</ul>
6060

61-
6261
## 解法
6362

6463
<!-- 这里可写通用的实现逻辑 -->
6564

65+
并查集。
66+
67+
模板 1——朴素并查集：
68+
69+
```python
70+
# 初始化，p存储每个点的父节点
71+
p = list(range(n))
72+
73+
# 返回x的祖宗节点
74+
def find(x):
75+
if p[x] != x:
76+
# 路径压缩
77+
p[x] = find(p[x])
78+
return p[x]
79+
80+
# 合并a和b所在的两个集合
81+
p[find(a)] = find(b)
82+
```
83+
84+
模板 2——维护 size 的并查集：
85+
86+
```python
87+
# 初始化，p存储每个点的父节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
88+
p = list(range(n))
89+
size = [1] * n
90+
91+
# 返回x的祖宗节点
92+
def find(x):
93+
if p[x] != x:
94+
# 路径压缩
95+
p[x] = find(p[x])
96+
return p[x]
97+
98+
# 合并a和b所在的两个集合
99+
if find(a) != find(b):
100+
size[find(b)] += size[find(a)]
101+
p[find(a)] = find(b)
102+
```
103+
104+
模板 3——维护到祖宗节点距离的并查集：
105+
106+
```python
107+
# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
108+
p = list(range(n))
109+
d = [0] * n
110+
111+
# 返回x的祖宗节点
112+
def find(x):
113+
if p[x] != x:
114+
t = find(p[x])
115+
d[x] += d[p[x]]
116+
p[x] = t
117+
return p[x]
118+
119+
# 合并a和b所在的两个集合
120+
p[find(a)] = find(b)
121+
d[find(a)] = distance
122+
```
123+
124+
对于本题，遍历每个节点 i 以及对应的左右孩子 l, r，用 vis 数组记录节点是否有父节点：
125+
126+
- 若孩子节点已存在父节点，说明有多个父亲，不满足条件，直接返回 false。
127+
- 若孩子节点与父节点已经处于同一个连通分量，说明会形成环，不满足条件，直接返回 false。
128+
- 否则，进行合并，并将节点 i 分别与 l, r 进行合并。
129+
130+
遍历结束，判断连通分量个数是否为 1，若是返回 true，否则返回 false。
131+
66132
<!-- tabs:start -->
67133

68134
### **Python3**
69135

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

72138
```python
73-
139+
class Solution:
140+
def validateBinaryTreeNodes(self, n: int, leftChild: List[int], rightChild: List[int]) -> bool:
141+
p = list(range(n))
142+
vis = [False] * n
143+
144+
def find(x):
145+
if p[x] != x:
146+
p[x] = find(p[x])
147+
return p[x]
148+
149+
for i in range(n):
150+
l, r = leftChild[i], rightChild[i]
151+
if l != -1:
152+
if vis[l] or find(i) == find(l):
153+
return False
154+
p[find(i)] = find(l)
155+
vis[l] = True
156+
n -= 1
157+
if r != -1:
158+
if vis[r] or find(i) == find(r):
159+
return False
160+
p[find(i)] = find(r)
161+
vis[r] = True
162+
n -= 1
163+
return n == 1
74164
```
75165

76166
### **Java**
77167

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

80170
```java
171+
class Solution {
172+
private int[] p;
173+
174+
public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
175+
p = new int[n];
176+
boolean[] vis = new boolean[n];
177+
for (int i = 0; i < n; ++i) {
178+
p[i] = i;
179+
}
180+
for (int i = 0, t = n; i < t; ++i) {
181+
int l = leftChild[i], r = rightChild[i];
182+
if (l != -1) {
183+
if (vis[l] || find(i) == find(l)) {
184+
return false;
185+
}
186+
vis[l] = true;
187+
p[find(i)] = find(l);
188+
--n;
189+
}
190+
if (r != -1) {
191+
if (vis[r] || find(i) == find(r)) {
192+
return false;
193+
}
194+
vis[r] = true;
195+
p[find(i)] = find(r);
196+
--n;
197+
}
198+
}
199+
return n == 1;
200+
}
201+
202+
private int find(int x) {
203+
if (p[x] != x) {
204+
p[x] = find(p[x]);
205+
}
206+
return p[x];
207+
}
208+
}
209+
```
210+
211+
### **C++**
212+
213+
```cpp
214+
class Solution {
215+
public:
216+
vector<int> p;
217+
218+
bool validateBinaryTreeNodes(int n, vector<int>& leftChild, vector<int>& rightChild) {
219+
p.resize(n);
220+
for (int i = 0; i < n; ++i) p[i] = i;
221+
vector<bool> vis(n, false);
222+
for (int i = 0, t = n; i < t; ++i)
223+
{
224+
int l = leftChild[i], r = rightChild[i];
225+
if (l != -1)
226+
{
227+
if (vis[l] || find(i) == find(l)) return false;
228+
vis[l] = true;
229+
p[find(i)] = find(l);
230+
--n;
231+
}
232+
if (r != -1)
233+
{
234+
if (vis[r] || find(i) == find(r)) return false;
235+
vis[r] = true;
236+
p[find(i)] = find(r);
237+
--n;
238+
}
239+
}
240+
return n == 1;
241+
}
242+
243+
int find(int x) {
244+
if (p[x] != x) p[x] = find(p[x]);
245+
return p[x];
246+
}
247+
};
248+
```
81249

250+
### **Go**
251+
252+
```go
253+
var p []int
254+
255+
func validateBinaryTreeNodes(n int, leftChild []int, rightChild []int) bool {
256+
p = make([]int, n)
257+
for i := 0; i < n; i++ {
258+
p[i] = i
259+
}
260+
vis := make([]bool, n)
261+
for i, t := 0, n; i < t; i++ {
262+
l, r := leftChild[i], rightChild[i]
263+
if l != -1 {
264+
if vis[l] || find(i) == find(l) {
265+
return false
266+
}
267+
vis[l] = true
268+
p[find(i)] = find(l)
269+
n--
270+
}
271+
if r != -1 {
272+
if vis[r] || find(i) == find(r) {
273+
return false
274+
}
275+
vis[r] = true
276+
p[find(i)] = find(r)
277+
n--
278+
}
279+
}
280+
return n == 1
281+
}
282+
283+
func find(x int) int {
284+
if p[x] != x {
285+
p[x] = find(p[x])
286+
}
287+
return p[x]
288+
}
82289
```
83290

84291
### **...**

‎solution/1300-1399/1361.Validate Binary Tree Nodes/README_EN.md

+144-1
Original file line numberDiff line numberDiff line change
@@ -51,18 +51,161 @@
5151

5252
## Solutions
5353

54+
Union find.
55+
5456
<!-- tabs:start -->
5557

5658
### **Python3**
5759

5860
```python
59-
61+
class Solution:
62+
def validateBinaryTreeNodes(self, n: int, leftChild: List[int], rightChild: List[int]) -> bool:
63+
p = list(range(n))
64+
vis = [False] * n
65+
66+
def find(x):
67+
if p[x] != x:
68+
p[x] = find(p[x])
69+
return p[x]
70+
71+
for i in range(n):
72+
l, r = leftChild[i], rightChild[i]
73+
if l != -1:
74+
if vis[l] or find(i) == find(l):
75+
return False
76+
p[find(i)] = find(l)
77+
vis[l] = True
78+
n -= 1
79+
if r != -1:
80+
if vis[r] or find(i) == find(r):
81+
return False
82+
p[find(i)] = find(r)
83+
vis[r] = True
84+
n -= 1
85+
return n == 1
6086
```
6187

6288
### **Java**
6389

6490
```java
91+
class Solution {
92+
private int[] p;
93+
94+
public boolean validateBinaryTreeNodes(int n, int[] leftChild, int[] rightChild) {
95+
p = new int[n];
96+
boolean[] vis = new boolean[n];
97+
for (int i = 0; i < n; ++i) {
98+
p[i] = i;
99+
}
100+
for (int i = 0, t = n; i < t; ++i) {
101+
int l = leftChild[i], r = rightChild[i];
102+
if (l != -1) {
103+
if (vis[l] || find(i) == find(l)) {
104+
return false;
105+
}
106+
vis[l] = true;
107+
p[find(i)] = find(l);
108+
--n;
109+
}
110+
if (r != -1) {
111+
if (vis[r] || find(i) == find(r)) {
112+
return false;
113+
}
114+
vis[r] = true;
115+
p[find(i)] = find(r);
116+
--n;
117+
}
118+
}
119+
return n == 1;
120+
}
121+
122+
private int find(int x) {
123+
if (p[x] != x) {
124+
p[x] = find(p[x]);
125+
}
126+
return p[x];
127+
}
128+
}
129+
```
130+
131+
### **C++**
132+
133+
```cpp
134+
class Solution {
135+
public:
136+
vector<int> p;
137+
138+
bool validateBinaryTreeNodes(int n, vector<int>& leftChild, vector<int>& rightChild) {
139+
p.resize(n);
140+
for (int i = 0; i < n; ++i) p[i] = i;
141+
vector<bool> vis(n, false);
142+
for (int i = 0, t = n; i < t; ++i)
143+
{
144+
int l = leftChild[i], r = rightChild[i];
145+
if (l != -1)
146+
{
147+
if (vis[l] || find(i) == find(l)) return false;
148+
vis[l] = true;
149+
p[find(i)] = find(l);
150+
--n;
151+
}
152+
if (r != -1)
153+
{
154+
if (vis[r] || find(i) == find(r)) return false;
155+
vis[r] = true;
156+
p[find(i)] = find(r);
157+
--n;
158+
}
159+
}
160+
return n == 1;
161+
}
162+
163+
int find(int x) {
164+
if (p[x] != x) p[x] = find(p[x]);
165+
return p[x];
166+
}
167+
};
168+
```
65169

170+
### **Go**
171+
172+
```go
173+
var p []int
174+
175+
func validateBinaryTreeNodes(n int, leftChild []int, rightChild []int) bool {
176+
p = make([]int, n)
177+
for i := 0; i < n; i++ {
178+
p[i] = i
179+
}
180+
vis := make([]bool, n)
181+
for i, t := 0, n; i < t; i++ {
182+
l, r := leftChild[i], rightChild[i]
183+
if l != -1 {
184+
if vis[l] || find(i) == find(l) {
185+
return false
186+
}
187+
vis[l] = true
188+
p[find(i)] = find(l)
189+
n--
190+
}
191+
if r != -1 {
192+
if vis[r] || find(i) == find(r) {
193+
return false
194+
}
195+
vis[r] = true
196+
p[find(i)] = find(r)
197+
n--
198+
}
199+
}
200+
return n == 1
201+
}
202+
203+
func find(x int) int {
204+
if p[x] != x {
205+
p[x] = find(p[x])
206+
}
207+
return p[x]
208+
}
66209
```
67210

68211
### **...**

0 commit comments

Comments
 (0)