Skip to content

Commit 3152624

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1368
No.1368.Minimum Cost to Make at Least One Valid Path in a Grid
1 parent c1543e6 commit 3152624

File tree

6 files changed

+365
-2
lines changed

6 files changed

+365
-2
lines changed

‎solution/1300-1399/1368.Minimum Cost to Make at Least One Valid Path in a Grid/README.md

Lines changed: 126 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -79,22 +79,147 @@
7979

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

82+
双端队列 BFS。
83+
8284
<!-- tabs:start -->
8385

8486
### **Python3**
8587

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

8890
```python
89-
91+
class Solution:
92+
def minCost(self, grid: List[List[int]]) -> int:
93+
m, n = len(grid), len(grid[0])
94+
dirs = [[0, 0], [0, 1], [0, -1], [1, 0], [-1, 0]]
95+
q = deque([(0, 0, 0)])
96+
vis = set()
97+
while q:
98+
i, j, d = q.popleft()
99+
if (i, j) in vis:
100+
continue
101+
vis.add((i, j))
102+
if i == m - 1 and j == n - 1:
103+
return d
104+
for k in range(1, 5):
105+
x, y = i + dirs[k][0], j + dirs[k][1]
106+
if 0 <= x < m and 0 <= y < n:
107+
if grid[i][j] == k:
108+
q.appendleft((x, y, d))
109+
else:
110+
q.append((x, y, d + 1))
111+
return -1
90112
```
91113

92114
### **Java**
93115

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

96118
```java
119+
class Solution {
120+
public int minCost(int[][] grid) {
121+
int m = grid.length, n = grid[0].length;
122+
boolean[][] vis = new boolean[m][n];
123+
Deque<int[]> q = new ArrayDeque<>();
124+
q.offer(new int[]{0, 0, 0});
125+
int[][] dirs = {{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}};
126+
while (!q.isEmpty()) {
127+
int[] p = q.poll();
128+
int i = p[0], j = p[1], d = p[2];
129+
if (i == m - 1 && j == n - 1) {
130+
return d;
131+
}
132+
if (vis[i][j]) {
133+
continue;
134+
}
135+
vis[i][j] = true;
136+
for (int k = 1; k <= 4; ++k) {
137+
int x = i + dirs[k][0], y = j + dirs[k][1];
138+
if (x >= 0 && x < m && y >= 0 && y < n) {
139+
if (grid[i][j] == k) {
140+
q.offerFirst(new int[]{x, y, d});
141+
} else {
142+
q.offer(new int[]{x, y, d + 1});
143+
}
144+
}
145+
}
146+
}
147+
return -1;
148+
}
149+
}
150+
```
151+
152+
### **C++**
153+
154+
```cpp
155+
class Solution {
156+
public:
157+
int minCost(vector<vector<int>>& grid) {
158+
int m = grid.size(), n = grid[0].size();
159+
vector<vector<bool>> vis(m, vector<bool>(n));
160+
vector<vector<int>> dirs = {{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}};
161+
deque<pair<int, int>> q;
162+
q.push_back({0, 0});
163+
while (!q.empty())
164+
{
165+
auto p = q.front();
166+
q.pop_front();
167+
int i = p.first / n, j = p.first % n, d = p.second;
168+
if (i == m - 1 && j == n - 1) return d;
169+
if (vis[i][j]) continue;
170+
vis[i][j] = true;
171+
for (int k = 1; k <= 4; ++k)
172+
{
173+
int x = i + dirs[k][0], y = j + dirs[k][1];
174+
if (x >= 0 && x < m && y >= 0 && y < n)
175+
{
176+
if (grid[i][j] == k) q.push_front({x * n + y, d});
177+
else q.push_back({x * n + y, d + 1});
178+
}
179+
}
180+
}
181+
return -1;
182+
}
183+
};
184+
```
97185
186+
### **Go**
187+
188+
```go
189+
func minCost(grid [][]int) int {
190+
m, n := len(grid), len(grid[0])
191+
q := doublylinkedlist.New()
192+
q.Add([]int{0, 0, 0})
193+
dirs := [][]int{{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}}
194+
vis := make([][]bool, m)
195+
for i := range vis {
196+
vis[i] = make([]bool, n)
197+
}
198+
for !q.Empty() {
199+
v, _ := q.Get(0)
200+
p := v.([]int)
201+
q.Remove(0)
202+
i, j, d := p[0], p[1], p[2]
203+
if i == m-1 && j == n-1 {
204+
return d
205+
}
206+
if vis[i][j] {
207+
continue
208+
}
209+
vis[i][j] = true
210+
for k := 1; k <= 4; k++ {
211+
x, y := i+dirs[k][0], j+dirs[k][1]
212+
if x >= 0 && x < m && y >= 0 && y < n {
213+
if grid[i][j] == k {
214+
q.Insert(0, []int{x, y, d})
215+
} else {
216+
q.Add([]int{x, y, d + 1})
217+
}
218+
}
219+
}
220+
}
221+
return -1
222+
}
98223
```
99224

100225
### **...**

‎solution/1300-1399/1368.Minimum Cost to Make at Least One Valid Path in a Grid/README_EN.md

Lines changed: 124 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -77,13 +77,136 @@ The total cost = 3.
7777
### **Python3**
7878

7979
```python
80-
80+
class Solution:
81+
def minCost(self, grid: List[List[int]]) -> int:
82+
m, n = len(grid), len(grid[0])
83+
dirs = [[0, 0], [0, 1], [0, -1], [1, 0], [-1, 0]]
84+
q = deque([(0, 0, 0)])
85+
vis = set()
86+
while q:
87+
i, j, d = q.popleft()
88+
if (i, j) in vis:
89+
continue
90+
vis.add((i, j))
91+
if i == m - 1 and j == n - 1:
92+
return d
93+
for k in range(1, 5):
94+
x, y = i + dirs[k][0], j + dirs[k][1]
95+
if 0 <= x < m and 0 <= y < n:
96+
if grid[i][j] == k:
97+
q.appendleft((x, y, d))
98+
else:
99+
q.append((x, y, d + 1))
100+
return -1
81101
```
82102

83103
### **Java**
84104

85105
```java
106+
class Solution {
107+
public int minCost(int[][] grid) {
108+
int m = grid.length, n = grid[0].length;
109+
boolean[][] vis = new boolean[m][n];
110+
Deque<int[]> q = new ArrayDeque<>();
111+
q.offer(new int[]{0, 0, 0});
112+
int[][] dirs = {{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}};
113+
while (!q.isEmpty()) {
114+
int[] p = q.poll();
115+
int i = p[0], j = p[1], d = p[2];
116+
if (i == m - 1 && j == n - 1) {
117+
return d;
118+
}
119+
if (vis[i][j]) {
120+
continue;
121+
}
122+
vis[i][j] = true;
123+
for (int k = 1; k <= 4; ++k) {
124+
int x = i + dirs[k][0], y = j + dirs[k][1];
125+
if (x >= 0 && x < m && y >= 0 && y < n) {
126+
if (grid[i][j] == k) {
127+
q.offerFirst(new int[]{x, y, d});
128+
} else {
129+
q.offer(new int[]{x, y, d + 1});
130+
}
131+
}
132+
}
133+
}
134+
return -1;
135+
}
136+
}
137+
```
138+
139+
### **C++**
140+
141+
```cpp
142+
class Solution {
143+
public:
144+
int minCost(vector<vector<int>>& grid) {
145+
int m = grid.size(), n = grid[0].size();
146+
vector<vector<bool>> vis(m, vector<bool>(n));
147+
vector<vector<int>> dirs = {{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}};
148+
deque<pair<int, int>> q;
149+
q.push_back({0, 0});
150+
while (!q.empty())
151+
{
152+
auto p = q.front();
153+
q.pop_front();
154+
int i = p.first / n, j = p.first % n, d = p.second;
155+
if (i == m - 1 && j == n - 1) return d;
156+
if (vis[i][j]) continue;
157+
vis[i][j] = true;
158+
for (int k = 1; k <= 4; ++k)
159+
{
160+
int x = i + dirs[k][0], y = j + dirs[k][1];
161+
if (x >= 0 && x < m && y >= 0 && y < n)
162+
{
163+
if (grid[i][j] == k) q.push_front({x * n + y, d});
164+
else q.push_back({x * n + y, d + 1});
165+
}
166+
}
167+
}
168+
return -1;
169+
}
170+
};
171+
```
86172
173+
### **Go**
174+
175+
```go
176+
func minCost(grid [][]int) int {
177+
m, n := len(grid), len(grid[0])
178+
q := doublylinkedlist.New()
179+
q.Add([]int{0, 0, 0})
180+
dirs := [][]int{{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}}
181+
vis := make([][]bool, m)
182+
for i := range vis {
183+
vis[i] = make([]bool, n)
184+
}
185+
for !q.Empty() {
186+
v, _ := q.Get(0)
187+
p := v.([]int)
188+
q.Remove(0)
189+
i, j, d := p[0], p[1], p[2]
190+
if i == m-1 && j == n-1 {
191+
return d
192+
}
193+
if vis[i][j] {
194+
continue
195+
}
196+
vis[i][j] = true
197+
for k := 1; k <= 4; k++ {
198+
x, y := i+dirs[k][0], j+dirs[k][1]
199+
if x >= 0 && x < m && y >= 0 && y < n {
200+
if grid[i][j] == k {
201+
q.Insert(0, []int{x, y, d})
202+
} else {
203+
q.Add([]int{x, y, d + 1})
204+
}
205+
}
206+
}
207+
}
208+
return -1
209+
}
87210
```
88211

89212
### **...**

‎solution/1300-1399/1368.Minimum Cost to Make at Least One Valid Path in a Grid/Solution.cpp

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
class Solution {
2+
public:
3+
int minCost(vector<vector<int>>& grid) {
4+
int m = grid.size(), n = grid[0].size();
5+
vector<vector<bool>> vis(m, vector<bool>(n));
6+
vector<vector<int>> dirs = {{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}};
7+
deque<pair<int, int>> q;
8+
q.push_back({0, 0});
9+
while (!q.empty())
10+
{
11+
auto p = q.front();
12+
q.pop_front();
13+
int i = p.first / n, j = p.first % n, d = p.second;
14+
if (i == m - 1 && j == n - 1) return d;
15+
if (vis[i][j]) continue;
16+
vis[i][j] = true;
17+
for (int k = 1; k <= 4; ++k)
18+
{
19+
int x = i + dirs[k][0], y = j + dirs[k][1];
20+
if (x >= 0 && x < m && y >= 0 && y < n)
21+
{
22+
if (grid[i][j] == k) q.push_front({x * n + y, d});
23+
else q.push_back({x * n + y, d + 1});
24+
}
25+
}
26+
}
27+
return -1;
28+
}
29+
};

‎solution/1300-1399/1368.Minimum Cost to Make at Least One Valid Path in a Grid/Solution.go

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
func minCost(grid [][]int) int {
2+
m, n := len(grid), len(grid[0])
3+
q := doublylinkedlist.New()
4+
q.Add([]int{0, 0, 0})
5+
dirs := [][]int{{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}}
6+
vis := make([][]bool, m)
7+
for i := range vis {
8+
vis[i] = make([]bool, n)
9+
}
10+
for !q.Empty() {
11+
v, _ := q.Get(0)
12+
p := v.([]int)
13+
q.Remove(0)
14+
i, j, d := p[0], p[1], p[2]
15+
if i == m-1 && j == n-1 {
16+
return d
17+
}
18+
if vis[i][j] {
19+
continue
20+
}
21+
vis[i][j] = true
22+
for k := 1; k <= 4; k++ {
23+
x, y := i+dirs[k][0], j+dirs[k][1]
24+
if x >= 0 && x < m && y >= 0 && y < n {
25+
if grid[i][j] == k {
26+
q.Insert(0, []int{x, y, d})
27+
} else {
28+
q.Add([]int{x, y, d + 1})
29+
}
30+
}
31+
}
32+
}
33+
return -1
34+
}

‎solution/1300-1399/1368.Minimum Cost to Make at Least One Valid Path in a Grid/Solution.java

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
class Solution {
2+
public int minCost(int[][] grid) {
3+
int m = grid.length, n = grid[0].length;
4+
boolean[][] vis = new boolean[m][n];
5+
Deque<int[]> q = new ArrayDeque<>();
6+
q.offer(new int[]{0, 0, 0});
7+
int[][] dirs = {{0, 0}, {0, 1}, {0, -1}, {1, 0}, {-1, 0}};
8+
while (!q.isEmpty()) {
9+
int[] p = q.poll();
10+
int i = p[0], j = p[1], d = p[2];
11+
if (i == m - 1 && j == n - 1) {
12+
return d;
13+
}
14+
if (vis[i][j]) {
15+
continue;
16+
}
17+
vis[i][j] = true;
18+
for (int k = 1; k <= 4; ++k) {
19+
int x = i + dirs[k][0], y = j + dirs[k][1];
20+
if (x >= 0 && x < m && y >= 0 && y < n) {
21+
if (grid[i][j] == k) {
22+
q.offerFirst(new int[]{x, y, d});
23+
} else {
24+
q.offer(new int[]{x, y, d + 1});
25+
}
26+
}
27+
}
28+
}
29+
return -1;
30+
}
31+
}

0 commit comments

Comments
 (0)