Skip to content

Commit 9da2d09

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1391.Check if There is a Valid
Path in a Grid
1 parent c3b0240 commit 9da2d09

File tree

4 files changed

+421
-4
lines changed

4 files changed

+421
-4
lines changed

‎solution/1300-1399/1391.Check if There is a Valid Path in a Grid/README.md

+181-2
Original file line numberDiff line numberDiff line change
@@ -80,22 +80,201 @@
8080

8181
<!-- 这里可写通用的实现逻辑 -->
8282

83+
并查集。
84+
85+
并查集模板：
86+
87+
模板 1——朴素并查集：
88+
89+
```python
90+
# 初始化，p存储每个点的父节点
91+
p = list(range(n))
92+
93+
# 返回x的祖宗节点
94+
def find(x):
95+
if p[x] != x:
96+
# 路径压缩
97+
p[x] = find(p[x])
98+
return p[x]
99+
100+
# 合并a和b所在的两个集合
101+
p[find(a)] = find(b)
102+
```
103+
104+
模板 2——维护 size 的并查集：
105+
106+
```python
107+
# 初始化，p存储每个点的父节点，size只有当节点是祖宗节点时才有意义，表示祖宗节点所在集合中，点的数量
108+
p = list(range(n))
109+
size = [1] * n
110+
111+
# 返回x的祖宗节点
112+
def find(x):
113+
if p[x] != x:
114+
# 路径压缩
115+
p[x] = find(p[x])
116+
return p[x]
117+
118+
# 合并a和b所在的两个集合
119+
if find(a) != find(b):
120+
size[find(b)] += size[find(a)]
121+
p[find(a)] = find(b)
122+
```
123+
124+
模板 3——维护到祖宗节点距离的并查集：
125+
126+
```python
127+
# 初始化，p存储每个点的父节点，d[x]存储x到p[x]的距离
128+
p = list(range(n))
129+
d = [0] * n
130+
131+
# 返回x的祖宗节点
132+
def find(x):
133+
if p[x] != x:
134+
t = find(p[x])
135+
d[x] += d[p[x]]
136+
p[x] = t
137+
return p[x]
138+
139+
# 合并a和b所在的两个集合
140+
p[find(a)] = find(b)
141+
d[find(a)] = distance
142+
```
143+
83144
<!-- tabs:start -->
84145

85146
### **Python3**
86147

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

89150
```python
90-
151+
class Solution:
152+
def hasValidPath(self, grid: List[List[int]]) -> bool:
153+
m, n = len(grid), len(grid[0])
154+
p = list(range(m * n))
155+
156+
def find(x):
157+
if p[x] != x:
158+
p[x] = find(p[x])
159+
return p[x]
160+
161+
def left(i, j):
162+
if j > 0 and grid[i][j - 1] in (1, 4, 6):
163+
p[find(i * n + j)] = find(i * n + j - 1)
164+
165+
def right(i, j):
166+
if j < n - 1 and grid[i][j + 1] in (1, 3, 5):
167+
p[find(i * n + j)] = find(i * n + j + 1)
168+
169+
def up(i, j):
170+
if i > 0 and grid[i - 1][j] in (2, 3, 4):
171+
p[find(i * n + j)] = find((i - 1) * n + j)
172+
173+
def down(i, j):
174+
if i < m - 1 and grid[i + 1][j] in (2, 5, 6):
175+
p[find(i * n + j)] = find((i + 1) * n + j)
176+
177+
for i in range(m):
178+
for j in range(n):
179+
e = grid[i][j]
180+
if e == 1:
181+
left(i, j)
182+
right(i, j)
183+
elif e == 2:
184+
up(i, j)
185+
down(i, j)
186+
elif e == 3:
187+
left(i, j)
188+
down(i, j)
189+
elif e == 4:
190+
right(i, j)
191+
down(i, j)
192+
elif e == 5:
193+
left(i, j)
194+
up(i, j)
195+
else:
196+
right(i, j)
197+
up(i, j)
198+
return find(0) == find(m * n - 1)
91199
```
92200

93201
### **Java**
94202

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

97205
```java
98-
206+
class Solution {
207+
private int[] p;
208+
private int[][] grid;
209+
private int m;
210+
private int n;
211+
212+
public boolean hasValidPath(int[][] grid) {
213+
this.grid = grid;
214+
m = grid.length;
215+
n = grid[0].length;
216+
p = new int[m * n];
217+
for (int i = 0; i < p.length; ++i) {
218+
p[i] = i;
219+
}
220+
for (int i = 0; i < m; ++i) {
221+
for (int j = 0; j < n; ++j) {
222+
int e = grid[i][j];
223+
if (e == 1) {
224+
left(i, j);
225+
right(i, j);
226+
} else if (e == 2) {
227+
up(i, j);
228+
down(i, j);
229+
} else if (e == 3) {
230+
left(i, j);
231+
down(i, j);
232+
} else if (e == 4) {
233+
right(i, j);
234+
down(i, j);
235+
} else if (e == 5) {
236+
left(i, j);
237+
up(i, j);
238+
} else {
239+
right(i, j);
240+
up(i, j);
241+
}
242+
}
243+
}
244+
return find(0) == find(m * n - 1);
245+
}
246+
247+
private int find(int x) {
248+
if (p[x] != x) {
249+
p[x] = find(p[x]);
250+
}
251+
return p[x];
252+
}
253+
254+
private void left(int i, int j) {
255+
if (j > 0 && (grid[i][j - 1] == 1 || grid[i][j - 1] == 4 || grid[i][j - 1] == 6)) {
256+
p[find(i * n + j)] = find(i * n + j - 1);
257+
}
258+
}
259+
260+
private void right(int i, int j) {
261+
if (j < n - 1 && (grid[i][j + 1] == 1 || grid[i][j + 1] == 3 || grid[i][j + 1] == 5)) {
262+
p[find(i * n + j)] = find(i * n + j + 1);
263+
}
264+
}
265+
266+
private void up(int i, int j) {
267+
if (i > 0 && (grid[i - 1][j] == 2 || grid[i - 1][j] == 3 || grid[i - 1][j] == 4)) {
268+
p[find(i * n + j)] = find((i - 1) * n + j);
269+
}
270+
}
271+
272+
private void down(int i, int j) {
273+
if (i < m - 1 && (grid[i + 1][j] == 2 || grid[i + 1][j] == 5 || grid[i + 1][j] == 6)) {
274+
p[find(i * n + j)] = find((i + 1) * n + j);
275+
}
276+
}
277+
}
99278
```
100279

101280
### **...**

‎solution/1300-1399/1391.Check if There is a Valid Path in a Grid/README_EN.md

+120-2
Original file line numberDiff line numberDiff line change
@@ -79,13 +79,131 @@ Given a <em>m</em> x <em>n</em> <code>grid</code>. Each cell of the <code>grid</
7979
### **Python3**
8080

8181
```python
82-
82+
class Solution:
83+
def hasValidPath(self, grid: List[List[int]]) -> bool:
84+
m, n = len(grid), len(grid[0])
85+
p = list(range(m * n))
86+
87+
def find(x):
88+
if p[x] != x:
89+
p[x] = find(p[x])
90+
return p[x]
91+
92+
def left(i, j):
93+
if j > 0 and grid[i][j - 1] in (1, 4, 6):
94+
p[find(i * n + j)] = find(i * n + j - 1)
95+
96+
def right(i, j):
97+
if j < n - 1 and grid[i][j + 1] in (1, 3, 5):
98+
p[find(i * n + j)] = find(i * n + j + 1)
99+
100+
def up(i, j):
101+
if i > 0 and grid[i - 1][j] in (2, 3, 4):
102+
p[find(i * n + j)] = find((i - 1) * n + j)
103+
104+
def down(i, j):
105+
if i < m - 1 and grid[i + 1][j] in (2, 5, 6):
106+
p[find(i * n + j)] = find((i + 1) * n + j)
107+
108+
for i in range(m):
109+
for j in range(n):
110+
e = grid[i][j]
111+
if e == 1:
112+
left(i, j)
113+
right(i, j)
114+
elif e == 2:
115+
up(i, j)
116+
down(i, j)
117+
elif e == 3:
118+
left(i, j)
119+
down(i, j)
120+
elif e == 4:
121+
right(i, j)
122+
down(i, j)
123+
elif e == 5:
124+
left(i, j)
125+
up(i, j)
126+
else:
127+
right(i, j)
128+
up(i, j)
129+
return find(0) == find(m * n - 1)
83130
```
84131

85132
### **Java**
86133

87134
```java
88-
135+
class Solution {
136+
private int[] p;
137+
private int[][] grid;
138+
private int m;
139+
private int n;
140+
141+
public boolean hasValidPath(int[][] grid) {
142+
this.grid = grid;
143+
m = grid.length;
144+
n = grid[0].length;
145+
p = new int[m * n];
146+
for (int i = 0; i < p.length; ++i) {
147+
p[i] = i;
148+
}
149+
for (int i = 0; i < m; ++i) {
150+
for (int j = 0; j < n; ++j) {
151+
int e = grid[i][j];
152+
if (e == 1) {
153+
left(i, j);
154+
right(i, j);
155+
} else if (e == 2) {
156+
up(i, j);
157+
down(i, j);
158+
} else if (e == 3) {
159+
left(i, j);
160+
down(i, j);
161+
} else if (e == 4) {
162+
right(i, j);
163+
down(i, j);
164+
} else if (e == 5) {
165+
left(i, j);
166+
up(i, j);
167+
} else {
168+
right(i, j);
169+
up(i, j);
170+
}
171+
}
172+
}
173+
return find(0) == find(m * n - 1);
174+
}
175+
176+
private int find(int x) {
177+
if (p[x] != x) {
178+
p[x] = find(p[x]);
179+
}
180+
return p[x];
181+
}
182+
183+
private void left(int i, int j) {
184+
if (j > 0 && (grid[i][j - 1] == 1 || grid[i][j - 1] == 4 || grid[i][j - 1] == 6)) {
185+
p[find(i * n + j)] = find(i * n + j - 1);
186+
}
187+
}
188+
189+
private void right(int i, int j) {
190+
if (j < n - 1 && (grid[i][j + 1] == 1 || grid[i][j + 1] == 3 || grid[i][j + 1] == 5)) {
191+
p[find(i * n + j)] = find(i * n + j + 1);
192+
}
193+
}
194+
195+
private void up(int i, int j) {
196+
if (i > 0 && (grid[i - 1][j] == 2 || grid[i - 1][j] == 3 || grid[i - 1][j] == 4)) {
197+
p[find(i * n + j)] = find((i - 1) * n + j);
198+
}
199+
}
200+
201+
private void down(int i, int j) {
202+
if (i < m - 1 && (grid[i + 1][j] == 2 || grid[i + 1][j] == 5 || grid[i + 1][j] == 6)) {
203+
p[find(i * n + j)] = find((i + 1) * n + j);
204+
}
205+
}
206+
}
89207
```
90208

91209
### **...**

0 commit comments

Comments
 (0)