Skip to content

Commit 816f7e5

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1293
No.1293.Shortest Path in a Grid with Obstacles Elimination
1 parent e567433 commit 816f7e5

File tree

6 files changed

+460
-2
lines changed

6 files changed

+460
-2
lines changed

‎solution/1200-1299/1293.Shortest Path in a Grid with Obstacles Elimination/README.md

+159-1
Original file line numberDiff line numberDiff line change
@@ -60,22 +60,180 @@ k = 1
6060

6161
<!-- 这里可写通用的实现逻辑 -->
6262

63+
BFS 最短路问题。
64+
65+
对于本题，如果 `k >= m + n - 3`，那么最短路径长度一定是 `m + n - 2`，直接返回，无需 BFS 计算。
66+
6367
<!-- tabs:start -->
6468

6569
### **Python3**
6670

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

6973
```python
70-
74+
class Solution:
75+
def shortestPath(self, grid: List[List[int]], k: int) -> int:
76+
m, n = len(grid), len(grid[0])
77+
if k >= m + n - 3:
78+
return m + n - 2
79+
q = deque([(0, 0, k)])
80+
vis = set([(0, 0, k)])
81+
ans = 0
82+
while q:
83+
ans += 1
84+
for _ in range(len(q), 0, -1):
85+
i, j, k = q.popleft()
86+
for a, b in [[0, -1], [0, 1], [1, 0], [-1, 0]]:
87+
x, y = i + a, j + b
88+
if 0 <= x < m and 0 <= y < n:
89+
if x == m - 1 and y == n - 1:
90+
return ans
91+
if grid[x][y] == 0 and (x, y, k) not in vis:
92+
q.append((x, y, k))
93+
vis.add((x, y, k))
94+
if grid[x][y] == 1 and k > 0 and (x, y, k - 1) not in vis:
95+
q.append((x, y, k - 1))
96+
vis.add((x, y, k - 1))
97+
return -1
7198
```
7299

73100
### **Java**
74101

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

77104
```java
105+
class Solution {
106+
public int shortestPath(int[][] grid, int k) {
107+
int m = grid.length;
108+
int n = grid[0].length;
109+
if (k >= m + n - 3) {
110+
return m + n - 2;
111+
}
112+
Deque<int[]> q = new ArrayDeque<>();
113+
q.offer(new int[]{0, 0, k});
114+
boolean[][][] vis = new boolean[m][n][k + 1];
115+
vis[0][0][k] = true;
116+
int ans = 0;
117+
int[] dirs = {-1, 0, 1, 0, -1};
118+
while (!q.isEmpty()) {
119+
++ans;
120+
for (int i = q.size(); i > 0; --i) {
121+
int[] p = q.poll();
122+
k = p[2];
123+
for (int j = 0; j < 4; ++j) {
124+
int x = p[0] + dirs[j];
125+
int y = p[1] + dirs[j + 1];
126+
if (x >= 0 && x < m && y >= 0 && y < n) {
127+
if (x == m - 1 && y == n - 1) {
128+
return ans;
129+
}
130+
if (grid[x][y] == 0 && !vis[x][y][k]) {
131+
q.offer(new int[]{x, y, k});
132+
vis[x][y][k] = true;
133+
} else if (grid[x][y] == 1 && k > 0 && !vis[x][y][k - 1]) {
134+
q.offer(new int[]{x, y, k - 1});
135+
vis[x][y][k - 1] = true;
136+
}
137+
}
138+
}
139+
}
140+
}
141+
return -1;
142+
}
143+
}
144+
```
145+
146+
### **C++**
147+
148+
```cpp
149+
class Solution {
150+
public:
151+
int shortestPath(vector<vector<int>>& grid, int k) {
152+
int m = grid.size(), n = grid[0].size();
153+
if (k >= m + n - 3) return m + n - 2;
154+
queue<vector<int>> q;
155+
q.push({0, 0, k});
156+
vector<vector<vector<bool>>> vis(m, vector<vector<bool>>(n, vector<bool>(k + 1)));
157+
vis[0][0][k] = true;
158+
int ans = 0;
159+
vector<int> dirs = {-1, 0, 1, 0, -1};
160+
while (!q.empty())
161+
{
162+
++ans;
163+
for (int i = q.size(); i > 0; --i)
164+
{
165+
auto p = q.front();
166+
k = p[2];
167+
q.pop();
168+
for (int j = 0; j < 4; ++j)
169+
{
170+
int x = p[0] + dirs[j], y = p[1] + dirs[j + 1];
171+
if (x >= 0 && x < m && y >= 0 && y < n)
172+
{
173+
if (x == m - 1 && y == n - 1) return ans;
174+
if (grid[x][y] == 0 && !vis[x][y][k])
175+
{
176+
q.push({x, y, k});
177+
vis[x][y][k] = true;
178+
}
179+
else if (grid[x][y] == 1 && k > 0 && !vis[x][y][k - 1])
180+
{
181+
q.push({x, y, k - 1});
182+
vis[x][y][k - 1] = true;
183+
}
184+
}
185+
}
186+
}
187+
}
188+
return -1;
189+
}
190+
};
191+
```
78192
193+
### **Go**
194+
195+
```go
196+
func shortestPath(grid [][]int, k int) int {
197+
m, n := len(grid), len(grid[0])
198+
if k >= m+n-3 {
199+
return m + n - 2
200+
}
201+
q := [][]int{[]int{0, 0, k}}
202+
vis := make([][][]bool, m)
203+
for i := range vis {
204+
vis[i] = make([][]bool, n)
205+
for j := range vis[i] {
206+
vis[i][j] = make([]bool, k+1)
207+
}
208+
}
209+
vis[0][0][k] = true
210+
dirs := []int{-1, 0, 1, 0, -1}
211+
ans := 0
212+
for len(q) > 0 {
213+
ans++
214+
for i := len(q); i > 0; i-- {
215+
p := q[0]
216+
q = q[1:]
217+
k = p[2]
218+
for j := 0; j < 4; j++ {
219+
x, y := p[0]+dirs[j], p[1]+dirs[j+1]
220+
if x >= 0 && x < m && y >= 0 && y < n {
221+
if x == m-1 && y == n-1 {
222+
return ans
223+
}
224+
if grid[x][y] == 0 && !vis[x][y][k] {
225+
q = append(q, []int{x, y, k})
226+
vis[x][y][k] = true
227+
} else if grid[x][y] == 1 && k > 0 && !vis[x][y][k-1] {
228+
q = append(q, []int{x, y, k - 1})
229+
vis[x][y][k-1] = true
230+
}
231+
}
232+
}
233+
}
234+
}
235+
return -1
236+
}
79237
```
80238

81239
### **...**

‎solution/1200-1299/1293.Shortest Path in a Grid with Obstacles Elimination/README_EN.md

+155-1
Original file line numberDiff line numberDiff line change
@@ -61,13 +61,167 @@ k = 1
6161
### **Python3**
6262

6363
```python
64-
64+
class Solution:
65+
def shortestPath(self, grid: List[List[int]], k: int) -> int:
66+
m, n = len(grid), len(grid[0])
67+
if k >= m + n - 3:
68+
return m + n - 2
69+
q = deque([(0, 0, k)])
70+
vis = set([(0, 0, k)])
71+
ans = 0
72+
while q:
73+
ans += 1
74+
for _ in range(len(q), 0, -1):
75+
i, j, k = q.popleft()
76+
for a, b in [[0, -1], [0, 1], [1, 0], [-1, 0]]:
77+
x, y = i + a, j + b
78+
if 0 <= x < m and 0 <= y < n:
79+
if x == m - 1 and y == n - 1:
80+
return ans
81+
if grid[x][y] == 0 and (x, y, k) not in vis:
82+
q.append((x, y, k))
83+
vis.add((x, y, k))
84+
if grid[x][y] == 1 and k > 0 and (x, y, k - 1) not in vis:
85+
q.append((x, y, k - 1))
86+
vis.add((x, y, k - 1))
87+
return -1
6588
```
6689

6790
### **Java**
6891

6992
```java
93+
class Solution {
94+
public int shortestPath(int[][] grid, int k) {
95+
int m = grid.length;
96+
int n = grid[0].length;
97+
if (k >= m + n - 3) {
98+
return m + n - 2;
99+
}
100+
Deque<int[]> q = new ArrayDeque<>();
101+
q.offer(new int[]{0, 0, k});
102+
boolean[][][] vis = new boolean[m][n][k + 1];
103+
vis[0][0][k] = true;
104+
int ans = 0;
105+
int[] dirs = {-1, 0, 1, 0, -1};
106+
while (!q.isEmpty()) {
107+
++ans;
108+
for (int i = q.size(); i > 0; --i) {
109+
int[] p = q.poll();
110+
k = p[2];
111+
for (int j = 0; j < 4; ++j) {
112+
int x = p[0] + dirs[j];
113+
int y = p[1] + dirs[j + 1];
114+
if (x >= 0 && x < m && y >= 0 && y < n) {
115+
if (x == m - 1 && y == n - 1) {
116+
return ans;
117+
}
118+
if (grid[x][y] == 0 && !vis[x][y][k]) {
119+
q.offer(new int[]{x, y, k});
120+
vis[x][y][k] = true;
121+
} else if (grid[x][y] == 1 && k > 0 && !vis[x][y][k - 1]) {
122+
q.offer(new int[]{x, y, k - 1});
123+
vis[x][y][k - 1] = true;
124+
}
125+
}
126+
}
127+
}
128+
}
129+
return -1;
130+
}
131+
}
132+
```
133+
134+
### **C++**
135+
136+
```cpp
137+
class Solution {
138+
public:
139+
int shortestPath(vector<vector<int>>& grid, int k) {
140+
int m = grid.size(), n = grid[0].size();
141+
if (k >= m + n - 3) return m + n - 2;
142+
queue<vector<int>> q;
143+
q.push({0, 0, k});
144+
vector<vector<vector<bool>>> vis(m, vector<vector<bool>>(n, vector<bool>(k + 1)));
145+
vis[0][0][k] = true;
146+
int ans = 0;
147+
vector<int> dirs = {-1, 0, 1, 0, -1};
148+
while (!q.empty())
149+
{
150+
++ans;
151+
for (int i = q.size(); i > 0; --i)
152+
{
153+
auto p = q.front();
154+
k = p[2];
155+
q.pop();
156+
for (int j = 0; j < 4; ++j)
157+
{
158+
int x = p[0] + dirs[j], y = p[1] + dirs[j + 1];
159+
if (x >= 0 && x < m && y >= 0 && y < n)
160+
{
161+
if (x == m - 1 && y == n - 1) return ans;
162+
if (grid[x][y] == 0 && !vis[x][y][k])
163+
{
164+
q.push({x, y, k});
165+
vis[x][y][k] = true;
166+
}
167+
else if (grid[x][y] == 1 && k > 0 && !vis[x][y][k - 1])
168+
{
169+
q.push({x, y, k - 1});
170+
vis[x][y][k - 1] = true;
171+
}
172+
}
173+
}
174+
}
175+
}
176+
return -1;
177+
}
178+
};
179+
```
70180
181+
### **Go**
182+
183+
```go
184+
func shortestPath(grid [][]int, k int) int {
185+
m, n := len(grid), len(grid[0])
186+
if k >= m+n-3 {
187+
return m + n - 2
188+
}
189+
q := [][]int{[]int{0, 0, k}}
190+
vis := make([][][]bool, m)
191+
for i := range vis {
192+
vis[i] = make([][]bool, n)
193+
for j := range vis[i] {
194+
vis[i][j] = make([]bool, k+1)
195+
}
196+
}
197+
vis[0][0][k] = true
198+
dirs := []int{-1, 0, 1, 0, -1}
199+
ans := 0
200+
for len(q) > 0 {
201+
ans++
202+
for i := len(q); i > 0; i-- {
203+
p := q[0]
204+
q = q[1:]
205+
k = p[2]
206+
for j := 0; j < 4; j++ {
207+
x, y := p[0]+dirs[j], p[1]+dirs[j+1]
208+
if x >= 0 && x < m && y >= 0 && y < n {
209+
if x == m-1 && y == n-1 {
210+
return ans
211+
}
212+
if grid[x][y] == 0 && !vis[x][y][k] {
213+
q = append(q, []int{x, y, k})
214+
vis[x][y][k] = true
215+
} else if grid[x][y] == 1 && k > 0 && !vis[x][y][k-1] {
216+
q = append(q, []int{x, y, k - 1})
217+
vis[x][y][k-1] = true
218+
}
219+
}
220+
}
221+
}
222+
}
223+
return -1
224+
}
71225
```
72226

73227
### **...**

‎solution/1200-1299/1293.Shortest Path in a Grid with Obstacles Elimination/Solution.cpp

+42
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
class Solution {
2+
public:
3+
int shortestPath(vector<vector<int>>& grid, int k) {
4+
int m = grid.size(), n = grid[0].size();
5+
if (k >= m + n - 3) return m + n - 2;
6+
queue<vector<int>> q;
7+
q.push({0, 0, k});
8+
vector<vector<vector<bool>>> vis(m, vector<vector<bool>>(n, vector<bool>(k + 1)));
9+
vis[0][0][k] = true;
10+
int ans = 0;
11+
vector<int> dirs = {-1, 0, 1, 0, -1};
12+
while (!q.empty())
13+
{
14+
++ans;
15+
for (int i = q.size(); i > 0; --i)
16+
{
17+
auto p = q.front();
18+
k = p[2];
19+
q.pop();
20+
for (int j = 0; j < 4; ++j)
21+
{
22+
int x = p[0] + dirs[j], y = p[1] + dirs[j + 1];
23+
if (x >= 0 && x < m && y >= 0 && y < n)
24+
{
25+
if (x == m - 1 && y == n - 1) return ans;
26+
if (grid[x][y] == 0 && !vis[x][y][k])
27+
{
28+
q.push({x, y, k});
29+
vis[x][y][k] = true;
30+
}
31+
else if (grid[x][y] == 1 && k > 0 && !vis[x][y][k - 1])
32+
{
33+
q.push({x, y, k - 1});
34+
vis[x][y][k - 1] = true;
35+
}
36+
}
37+
}
38+
}
39+
}
40+
return -1;
41+
}
42+
};

0 commit comments

Comments
 (0)