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 ae484ea

Browse files
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‎

Lines changed: 209 additions & 2 deletions
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‎

Lines changed: 144 additions & 1 deletion
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)

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