Skip to content

Commit 8bc0204

Browse files
yanglbmeyanglbme
committed
feat: add solution to lc problem: No.0261
No.0261.Graph Valid Tree
1 parent 93e15c2 commit 8bc0204

File tree

7 files changed

+155
-88
lines changed

7 files changed

+155
-88
lines changed

‎solution/0200-0299/0261.Graph Valid Tree/README.md

Lines changed: 53 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -92,13 +92,12 @@ d[find(a)] = distance
9292
```python
9393
class Solution:
9494
def validTree(self, n: int, edges: List[List[int]]) -> bool:
95-
p = list(range(n))
96-
9795
def find(x):
9896
if p[x] != x:
9997
p[x] = find(p[x])
10098
return p[x]
10199

100+
p = list(range(n))
102101
for a, b in edges:
103102
if find(a) == find(b):
104103
return False
@@ -121,10 +120,11 @@ class Solution {
121120
p[i] = i;
122121
}
123122
for (int[] e : edges) {
124-
if (find(e[0]) == find(e[1])) {
123+
int a = e[0], b = e[1];
124+
if (find(a) == find(b)) {
125125
return false;
126126
}
127-
p[find(e[0])] = find(e[1]);
127+
p[find(a)] = find(b);
128128
--n;
129129
}
130130
return n == 1;
@@ -146,26 +146,21 @@ class Solution {
146146
public:
147147
vector<int> p;
148148

149-
bool validTree(int n, vector<vector<int>> &edges) {
150-
for (int i = 0; i < n; ++i)
151-
{
152-
p.push_back(i);
153-
}
154-
for (auto e : edges)
149+
bool validTree(int n, vector<vector<int>>& edges) {
150+
p.resize(n);
151+
for (int i = 0; i < n; ++i) p[i] = i;
152+
for (auto& e : edges)
155153
{
156-
if (find(e[0]) == find(e[1]))
157-
return false;
158-
p[find(e[0])] = find(e[1]);
154+
int a = e[0], b = e[1];
155+
if (find(a) == find(b)) return 0;
156+
p[find(a)] = find(b);
159157
--n;
160158
}
161159
return n == 1;
162160
}
163161

164162
int find(int x) {
165-
if (p[x] != x)
166-
{
167-
p[x] = find(p[x]);
168-
}
163+
if (p[x] != x) p[x] = find(p[x]);
169164
return p[x];
170165
}
171166
};
@@ -174,29 +169,58 @@ public:
174169
### **Go**
175170
176171
```go
177-
var p []int
178-
179172
func validTree(n int, edges [][]int) bool {
180-
p = make([]int, n)
181-
for i := 0; i < n; i++ {
173+
p := make([]int, n)
174+
for i := range p {
182175
p[i] = i
183176
}
177+
var find func(x int) int
178+
find = func(x int) int {
179+
if p[x] != x {
180+
p[x] = find(p[x])
181+
}
182+
return p[x]
183+
}
184184
for _, e := range edges {
185-
if find(e[0]) == find(e[1]) {
185+
a, b := e[0], e[1]
186+
if find(a) == find(b) {
186187
return false
187188
}
188-
p[find(e[0])] = find(e[1])
189+
p[find(a)] = find(b)
189190
n--
190191
}
191192
return n == 1
192193
}
194+
```
193195

194-
func find(x int) int {
195-
if p[x] != x {
196-
p[x] = find(p[x])
197-
}
198-
return p[x]
199-
}
196+
### **JavaScript**
197+
198+
```js
199+
/**
200+
* @param {number} n
201+
* @param {number[][]} edges
202+
* @return {boolean}
203+
*/
204+
var validTree = function (n, edges) {
205+
let p = new Array(n);
206+
for (let i = 0; i < n; ++i) {
207+
p[i] = i;
208+
}
209+
function find(x) {
210+
if (p[x] != x) {
211+
p[x] = find(p[x]);
212+
}
213+
return p[x];
214+
}
215+
for (const [a, b] of edges) {
216+
if (find(a) == find(b)) {
217+
return false;
218+
}
219+
p[find(a)] = find(b);
220+
--n;
221+
}
222+
return n == 1;
223+
};
200224
```
201225

202226
### **...**

‎solution/0200-0299/0261.Graph Valid Tree/README_EN.md

Lines changed: 53 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -46,13 +46,12 @@ Union find.
4646
```python
4747
class Solution:
4848
def validTree(self, n: int, edges: List[List[int]]) -> bool:
49-
p = list(range(n))
50-
5149
def find(x):
5250
if p[x] != x:
5351
p[x] = find(p[x])
5452
return p[x]
5553

54+
p = list(range(n))
5655
for a, b in edges:
5756
if find(a) == find(b):
5857
return False
@@ -73,10 +72,11 @@ class Solution {
7372
p[i] = i;
7473
}
7574
for (int[] e : edges) {
76-
if (find(e[0]) == find(e[1])) {
75+
int a = e[0], b = e[1];
76+
if (find(a) == find(b)) {
7777
return false;
7878
}
79-
p[find(e[0])] = find(e[1]);
79+
p[find(a)] = find(b);
8080
--n;
8181
}
8282
return n == 1;
@@ -98,26 +98,21 @@ class Solution {
9898
public:
9999
vector<int> p;
100100

101-
bool validTree(int n, vector<vector<int>> &edges) {
102-
for (int i = 0; i < n; ++i)
101+
bool validTree(int n, vector<vector<int>>& edges) {
102+
p.resize(n);
103+
for (int i = 0; i < n; ++i) p[i] = i;
104+
for (auto& e : edges)
103105
{
104-
p.push_back(i);
105-
}
106-
for (auto e : edges)
107-
{
108-
if (find(e[0]) == find(e[1]))
109-
return false;
110-
p[find(e[0])] = find(e[1]);
106+
int a = e[0], b = e[1];
107+
if (find(a) == find(b)) return 0;
108+
p[find(a)] = find(b);
111109
--n;
112110
}
113111
return n == 1;
114112
}
115113

116114
int find(int x) {
117-
if (p[x] != x)
118-
{
119-
p[x] = find(p[x]);
120-
}
115+
if (p[x] != x) p[x] = find(p[x]);
121116
return p[x];
122117
}
123118
};
@@ -126,29 +121,58 @@ public:
126121
### **Go**
127122
128123
```go
129-
var p []int
130-
131124
func validTree(n int, edges [][]int) bool {
132-
p = make([]int, n)
133-
for i := 0; i < n; i++ {
125+
p := make([]int, n)
126+
for i := range p {
134127
p[i] = i
135128
}
129+
var find func(x int) int
130+
find = func(x int) int {
131+
if p[x] != x {
132+
p[x] = find(p[x])
133+
}
134+
return p[x]
135+
}
136136
for _, e := range edges {
137-
if find(e[0]) == find(e[1]) {
137+
a, b := e[0], e[1]
138+
if find(a) == find(b) {
138139
return false
139140
}
140-
p[find(e[0])] = find(e[1])
141+
p[find(a)] = find(b)
141142
n--
142143
}
143144
return n == 1
144145
}
146+
```
145147

146-
func find(x int) int {
147-
if p[x] != x {
148-
p[x] = find(p[x])
149-
}
150-
return p[x]
151-
}
148+
### **JavaScript**
149+
150+
```js
151+
/**
152+
* @param {number} n
153+
* @param {number[][]} edges
154+
* @return {boolean}
155+
*/
156+
var validTree = function (n, edges) {
157+
let p = new Array(n);
158+
for (let i = 0; i < n; ++i) {
159+
p[i] = i;
160+
}
161+
function find(x) {
162+
if (p[x] != x) {
163+
p[x] = find(p[x]);
164+
}
165+
return p[x];
166+
}
167+
for (const [a, b] of edges) {
168+
if (find(a) == find(b)) {
169+
return false;
170+
}
171+
p[find(a)] = find(b);
172+
--n;
173+
}
174+
return n == 1;
175+
};
152176
```
153177

154178
### **...**

‎solution/0200-0299/0261.Graph Valid Tree/Solution.cpp

Lines changed: 8 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -2,26 +2,21 @@ class Solution {
22
public:
33
vector<int> p;
44

5-
bool validTree(int n, vector<vector<int>> &edges) {
6-
for (int i = 0; i < n; ++i)
5+
bool validTree(int n, vector<vector<int>>& edges) {
6+
p.resize(n);
7+
for (int i = 0; i < n; ++i) p[i] = i;
8+
for (auto& e : edges)
79
{
8-
p.push_back(i);
9-
}
10-
for (auto e : edges)
11-
{
12-
if (find(e[0]) == find(e[1]))
13-
return false;
14-
p[find(e[0])] = find(e[1]);
10+
int a = e[0], b = e[1];
11+
if (find(a) == find(b)) return 0;
12+
p[find(a)] = find(b);
1513
--n;
1614
}
1715
return n == 1;
1816
}
1917

2018
int find(int x) {
21-
if (p[x] != x)
22-
{
23-
p[x] = find(p[x]);
24-
}
19+
if (p[x] != x) p[x] = find(p[x]);
2520
return p[x];
2621
}
2722
};

‎solution/0200-0299/0261.Graph Valid Tree/Solution.go

Lines changed: 12 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,23 +1,22 @@
1-
var p []int
2-
31
func validTree(n int, edges [][]int) bool {
4-
p = make([]int, n)
5-
for i := 0; i < n; i++ {
2+
p := make([]int, n)
3+
for i := range p {
64
p[i] = i
75
}
6+
var find func(x int) int
7+
find = func(x int) int {
8+
if p[x] != x {
9+
p[x] = find(p[x])
10+
}
11+
return p[x]
12+
}
813
for _, e := range edges {
9-
if find(e[0]) == find(e[1]) {
14+
a, b := e[0], e[1]
15+
if find(a) == find(b) {
1016
return false
1117
}
12-
p[find(e[0])] = find(e[1])
18+
p[find(a)] = find(b)
1319
n--
1420
}
1521
return n == 1
16-
}
17-
18-
func find(x int) int {
19-
if p[x] != x {
20-
p[x] = find(p[x])
21-
}
22-
return p[x]
2322
}

‎solution/0200-0299/0261.Graph Valid Tree/Solution.java

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,10 +7,11 @@ public boolean validTree(int n, int[][] edges) {
77
p[i] = i;
88
}
99
for (int[] e : edges) {
10-
if (find(e[0]) == find(e[1])) {
10+
int a = e[0], b = e[1];
11+
if (find(a) == find(b)) {
1112
return false;
1213
}
13-
p[find(e[0])] = find(e[1]);
14+
p[find(a)] = find(b);
1415
--n;
1516
}
1617
return n == 1;

‎solution/0200-0299/0261.Graph Valid Tree/Solution.js

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
/**
2+
* @param {number} n
3+
* @param {number[][]} edges
4+
* @return {boolean}
5+
*/
6+
var validTree = function (n, edges) {
7+
let p = new Array(n);
8+
for (let i = 0; i < n; ++i) {
9+
p[i] = i;
10+
}
11+
function find(x) {
12+
if (p[x] != x) {
13+
p[x] = find(p[x]);
14+
}
15+
return p[x];
16+
}
17+
for (const [a, b] of edges) {
18+
if (find(a) == find(b)) {
19+
return false;
20+
}
21+
p[find(a)] = find(b);
22+
--n;
23+
}
24+
return n == 1;
25+
};

‎solution/0200-0299/0261.Graph Valid Tree/Solution.py

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,11 @@
11
class Solution:
22
def validTree(self, n: int, edges: List[List[int]]) -> bool:
3-
p = list(range(n))
4-
53
def find(x):
64
if p[x] != x:
75
p[x] = find(p[x])
86
return p[x]
97

8+
p = list(range(n))
109
for a, b in edges:
1110
if find(a) == find(b):
1211
return False

0 commit comments

Comments
 (0)