Skip to content

Commit b37e41c

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1210
No.1210.Minimum Moves to Reach Target with Rotations
1 parent 3ca031c commit b37e41c

File tree

6 files changed

+499
-2
lines changed

6 files changed

+499
-2
lines changed

‎solution/1200-1299/1210.Minimum Moves to Reach Target with Rotations/README.md

Lines changed: 170 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -67,22 +67,191 @@
6767

6868
<!-- 这里可写通用的实现逻辑 -->
6969

70+
**方法一：BFS**
71+
7072
<!-- tabs:start -->
7173

7274
### **Python3**
7375

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

7678
```python
77-
79+
class Solution:
80+
def minimumMoves(self, grid: List[List[int]]) -> int:
81+
def check(a, b):
82+
if (a, b) not in vis:
83+
vis.add((a, b))
84+
q.append((a, b))
85+
86+
n = len(grid)
87+
target = (n * n - 2, n * n - 1)
88+
q = deque([(0, 1)])
89+
vis = set([(0, 1)])
90+
ans = 0
91+
while q:
92+
for _ in range(len(q)):
93+
a, b = q.popleft()
94+
if (a, b) == target:
95+
return ans
96+
i1, j1 = a // n, a % n
97+
i2, j2 = b // n, b % n
98+
if j1 + 1 < n and j2 + 1 < n and grid[i1][j1 + 1] == 0 and grid[i2][j2 + 1] == 0:
99+
check(i1 * n + j1 + 1, i2 * n + j2 + 1)
100+
if j1 == j2:
101+
check(a, i1 * n + j2 + 1)
102+
if i1 + 1 < n and i2 + 1 < n and grid[i1 + 1][j1] == 0 and grid[i2 + 1][j2] == 0:
103+
check((i1 + 1) * n + j1, (i2 + 1) * n + j2)
104+
if i1 == i2:
105+
check(a, (i2 + 1) * n + j1)
106+
ans += 1
107+
return -1
78108
```
79109

80110
### **Java**
81111

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

84114
```java
115+
class Solution {
116+
public int minimumMoves(int[][] grid) {
117+
int n = grid.length;
118+
int[] target = new int[]{n * n - 2, n * n - 1};
119+
Deque<int[]> q = new ArrayDeque<>();
120+
q.offer(new int[]{0, 1});
121+
boolean[][] vis = new boolean[n * n][n * n];
122+
int ans = 0;
123+
vis[0][1] = true;
124+
while (!q.isEmpty()) {
125+
for (int k = q.size(); k > 0; --k) {
126+
int[] p = q.poll();
127+
if (p[0] == target[0] && p[1] == target[1]) {
128+
return ans;
129+
}
130+
int a = p[0], b = p[1];
131+
int i1 = a / n, j1 = a % n;
132+
int i2 = b / n, j2 = b % n;
133+
if (j1 + 1 < n && j2 + 1 < n && grid[i1][j1 + 1] == 0 && grid[i2][j2 + 1] == 0) {
134+
check(i1 * n + j1 + 1, i2 * n + j2 + 1, q, vis);
135+
if (j1 == j2) {
136+
check(a, i1 * n + j2 + 1, q, vis);
137+
}
138+
}
139+
if (i1 + 1 < n && i2 + 1 < n && grid[i1 + 1][j1] == 0 && grid[i2 + 1][j2] == 0) {
140+
check((i1 + 1) * n + j1, (i2 + 1) * n + j2, q, vis);
141+
if (i1 == i2) {
142+
check(a, (i2 + 1) * n + j1, q, vis);
143+
}
144+
}
145+
}
146+
++ans;
147+
}
148+
return -1;
149+
}
150+
151+
private void check(int a, int b, Deque<int[]> q, boolean[][] vis) {
152+
if (!vis[a][b]) {
153+
vis[a][b] = true;
154+
q.offer(new int[]{a, b});
155+
}
156+
}
157+
}
158+
```
159+
160+
### **C++**
161+
162+
```cpp
163+
class Solution {
164+
public:
165+
int minimumMoves(vector<vector<int>>& grid) {
166+
int n = grid.size();
167+
vector<int> target = {n * n - 2, n * n - 1};
168+
queue<vector<int>> q;
169+
q.push({0, 1});
170+
vector<vector<bool>> vis(n * n, vector<bool>(n * n));
171+
int ans = 0;
172+
vis[0][1] = true;
173+
while (!q.empty())
174+
{
175+
for (int k = q.size(); k; --k)
176+
{
177+
auto p = q.front();
178+
if (p == target) return ans;
179+
q.pop();
180+
int a = p[0], b = p[1];
181+
int i1 = a / n, j1 = a % n;
182+
int i2 = b / n, j2 = b % n;
183+
if (j1 + 1 < n && j2 + 1 < n && grid[i1][j1 + 1] == 0 && grid[i2][j2 + 1] == 0)
184+
{
185+
check(i1 * n + j1 + 1, i2 * n + j2 + 1, q, vis);
186+
if (j1 == j2) check(a, i1 * n + j2 + 1, q, vis);
187+
}
188+
if (i1 + 1 < n && i2 + 1 < n && grid[i1 + 1][j1] == 0 && grid[i2 + 1][j2] == 0)
189+
{
190+
check((i1 + 1) * n + j1, (i2 + 1) * n + j2, q, vis);
191+
if (i1 == i2) check(a, (i2 + 1) * n + j1, q, vis);
192+
}
193+
}
194+
++ans;
195+
}
196+
return -1;
197+
}
198+
199+
void check(int a, int b, queue<vector<int>>& q, vector<vector<bool>>& vis) {
200+
if (!vis[a][b])
201+
{
202+
vis[a][b] = true;
203+
q.push({a, b});
204+
}
205+
}
206+
};
207+
```
85208

209+
### **Go**
210+
211+
```go
212+
func minimumMoves(grid [][]int) int {
213+
n := len(grid)
214+
target := []int{n*n - 2, n*n - 1}
215+
q := [][]int{{0, 1}}
216+
vis := make([][]bool, n*n)
217+
for i := range vis {
218+
vis[i] = make([]bool, n*n)
219+
}
220+
vis[0][1] = true
221+
ans := 0
222+
check := func(a, b int) {
223+
if !vis[a][b] {
224+
vis[a][b] = true
225+
q = append(q, []int{a, b})
226+
}
227+
}
228+
for len(q) > 0 {
229+
for k := len(q); k > 0; k-- {
230+
p := q[0]
231+
q = q[1:]
232+
if p[0] == target[0] && p[1] == target[1] {
233+
return ans
234+
}
235+
a, b := p[0], p[1]
236+
i1, j1 := a/n, a%n
237+
i2, j2 := b/n, b%n
238+
if j1+1 < n && j2+1 < n && grid[i1][j1+1] == 0 && grid[i2][j2+1] == 0 {
239+
check(i1*n+j1+1, i2*n+j2+1)
240+
if j1 == j2 {
241+
check(a, i1*n+j2+1)
242+
}
243+
}
244+
if i1+1 < n && i2+1 < n && grid[i1+1][j1] == 0 && grid[i2+1][j2] == 0 {
245+
check((i1+1)*n+j1, (i2+1)*n+j2)
246+
if i1 == i2 {
247+
check(a, (i2+1)*n+j1)
248+
}
249+
}
250+
}
251+
ans++
252+
}
253+
return -1
254+
}
86255
```
87256

88257
### **...**

‎solution/1200-1299/1210.Minimum Moves to Reach Target with Rotations/README_EN.md

Lines changed: 170 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -61,18 +61,187 @@
6161

6262
## Solutions
6363

64+
BFS.
65+
6466
<!-- tabs:start -->
6567

6668
### **Python3**
6769

6870
```python
69-
71+
class Solution:
72+
def minimumMoves(self, grid: List[List[int]]) -> int:
73+
def check(a, b):
74+
if (a, b) not in vis:
75+
vis.add((a, b))
76+
q.append((a, b))
77+
78+
n = len(grid)
79+
target = (n * n - 2, n * n - 1)
80+
q = deque([(0, 1)])
81+
vis = set([(0, 1)])
82+
ans = 0
83+
while q:
84+
for _ in range(len(q)):
85+
a, b = q.popleft()
86+
if (a, b) == target:
87+
return ans
88+
i1, j1 = a // n, a % n
89+
i2, j2 = b // n, b % n
90+
if j1 + 1 < n and j2 + 1 < n and grid[i1][j1 + 1] == 0 and grid[i2][j2 + 1] == 0:
91+
check(i1 * n + j1 + 1, i2 * n + j2 + 1)
92+
if j1 == j2:
93+
check(a, i1 * n + j2 + 1)
94+
if i1 + 1 < n and i2 + 1 < n and grid[i1 + 1][j1] == 0 and grid[i2 + 1][j2] == 0:
95+
check((i1 + 1) * n + j1, (i2 + 1) * n + j2)
96+
if i1 == i2:
97+
check(a, (i2 + 1) * n + j1)
98+
ans += 1
99+
return -1
70100
```
71101

72102
### **Java**
73103

74104
```java
105+
class Solution {
106+
public int minimumMoves(int[][] grid) {
107+
int n = grid.length;
108+
int[] target = new int[]{n * n - 2, n * n - 1};
109+
Deque<int[]> q = new ArrayDeque<>();
110+
q.offer(new int[]{0, 1});
111+
boolean[][] vis = new boolean[n * n][n * n];
112+
int ans = 0;
113+
vis[0][1] = true;
114+
while (!q.isEmpty()) {
115+
for (int k = q.size(); k > 0; --k) {
116+
int[] p = q.poll();
117+
if (p[0] == target[0] && p[1] == target[1]) {
118+
return ans;
119+
}
120+
int a = p[0], b = p[1];
121+
int i1 = a / n, j1 = a % n;
122+
int i2 = b / n, j2 = b % n;
123+
if (j1 + 1 < n && j2 + 1 < n && grid[i1][j1 + 1] == 0 && grid[i2][j2 + 1] == 0) {
124+
check(i1 * n + j1 + 1, i2 * n + j2 + 1, q, vis);
125+
if (j1 == j2) {
126+
check(a, i1 * n + j2 + 1, q, vis);
127+
}
128+
}
129+
if (i1 + 1 < n && i2 + 1 < n && grid[i1 + 1][j1] == 0 && grid[i2 + 1][j2] == 0) {
130+
check((i1 + 1) * n + j1, (i2 + 1) * n + j2, q, vis);
131+
if (i1 == i2) {
132+
check(a, (i2 + 1) * n + j1, q, vis);
133+
}
134+
}
135+
}
136+
++ans;
137+
}
138+
return -1;
139+
}
140+
141+
private void check(int a, int b, Deque<int[]> q, boolean[][] vis) {
142+
if (!vis[a][b]) {
143+
vis[a][b] = true;
144+
q.offer(new int[]{a, b});
145+
}
146+
}
147+
}
148+
```
149+
150+
### **C++**
151+
152+
```cpp
153+
class Solution {
154+
public:
155+
int minimumMoves(vector<vector<int>>& grid) {
156+
int n = grid.size();
157+
vector<int> target = {n * n - 2, n * n - 1};
158+
queue<vector<int>> q;
159+
q.push({0, 1});
160+
vector<vector<bool>> vis(n * n, vector<bool>(n * n));
161+
int ans = 0;
162+
vis[0][1] = true;
163+
while (!q.empty())
164+
{
165+
for (int k = q.size(); k; --k)
166+
{
167+
auto p = q.front();
168+
if (p == target) return ans;
169+
q.pop();
170+
int a = p[0], b = p[1];
171+
int i1 = a / n, j1 = a % n;
172+
int i2 = b / n, j2 = b % n;
173+
if (j1 + 1 < n && j2 + 1 < n && grid[i1][j1 + 1] == 0 && grid[i2][j2 + 1] == 0)
174+
{
175+
check(i1 * n + j1 + 1, i2 * n + j2 + 1, q, vis);
176+
if (j1 == j2) check(a, i1 * n + j2 + 1, q, vis);
177+
}
178+
if (i1 + 1 < n && i2 + 1 < n && grid[i1 + 1][j1] == 0 && grid[i2 + 1][j2] == 0)
179+
{
180+
check((i1 + 1) * n + j1, (i2 + 1) * n + j2, q, vis);
181+
if (i1 == i2) check(a, (i2 + 1) * n + j1, q, vis);
182+
}
183+
}
184+
++ans;
185+
}
186+
return -1;
187+
}
188+
189+
void check(int a, int b, queue<vector<int>>& q, vector<vector<bool>>& vis) {
190+
if (!vis[a][b])
191+
{
192+
vis[a][b] = true;
193+
q.push({a, b});
194+
}
195+
}
196+
};
197+
```
75198

199+
### **Go**
200+
201+
```go
202+
func minimumMoves(grid [][]int) int {
203+
n := len(grid)
204+
target := []int{n*n - 2, n*n - 1}
205+
q := [][]int{{0, 1}}
206+
vis := make([][]bool, n*n)
207+
for i := range vis {
208+
vis[i] = make([]bool, n*n)
209+
}
210+
vis[0][1] = true
211+
ans := 0
212+
check := func(a, b int) {
213+
if !vis[a][b] {
214+
vis[a][b] = true
215+
q = append(q, []int{a, b})
216+
}
217+
}
218+
for len(q) > 0 {
219+
for k := len(q); k > 0; k-- {
220+
p := q[0]
221+
q = q[1:]
222+
if p[0] == target[0] && p[1] == target[1] {
223+
return ans
224+
}
225+
a, b := p[0], p[1]
226+
i1, j1 := a/n, a%n
227+
i2, j2 := b/n, b%n
228+
if j1+1 < n && j2+1 < n && grid[i1][j1+1] == 0 && grid[i2][j2+1] == 0 {
229+
check(i1*n+j1+1, i2*n+j2+1)
230+
if j1 == j2 {
231+
check(a, i1*n+j2+1)
232+
}
233+
}
234+
if i1+1 < n && i2+1 < n && grid[i1+1][j1] == 0 && grid[i2+1][j2] == 0 {
235+
check((i1+1)*n+j1, (i2+1)*n+j2)
236+
if i1 == i2 {
237+
check(a, (i2+1)*n+j1)
238+
}
239+
}
240+
}
241+
ans++
242+
}
243+
return -1
244+
}
76245
```
77246

78247
### **...**

0 commit comments

Comments
 (0)