Skip to content

feat: add solutions to lc problem: No.0909 #3261

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jul 12, 2024
Merged

feat: add solutions to lc problem: No.0909 #3261

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
207 changes: 118 additions & 89 deletions solution/0900-0999/0909.Snakes and Ladders/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -88,35 +88,44 @@ tags:

### 方法一：BFS

我们可以使用广度优先搜索的方法，从起点开始，每次向前走 1 到 6 步，然后判断是否有蛇或梯子，如果有，就走到蛇或梯子的目的地，否则就走到下一个方格。

具体地，我们使用一个队列 $\textit{q}$ 来存储当前可以到达的方格编号，初始时将编号 $1$ 放入队列。同时我们使用一个集合 $\textit{vis}$ 来记录已经到达过的方格，避免重复访问，初始时将编号 $1$ 加入集合 $\textit{vis}$。

在每一次的操作中，我们取出队首的方格编号 $x$，如果 $x$ 是终点，那么我们就可以返回当前的步数。否则我们将 $x$ 向前走 $1$ 到 $6$ 步，设新的编号为 $y$，如果 $y$ 落在棋盘外，那么我们就直接跳过。否则，我们需要找到 $y$ 对应的行和列，由于行的编号是从下到上递减的，而列的编号与行的奇偶性有关，因此我们需要进行一些计算得到 $y$ 对应的行和列。

如果 $y$ 对应的方格上有蛇或梯子，那么我们需要额外走到蛇或梯子的目的地，设其为 $z$。如果 $z$ 没有被访问过，我们就将 $z$ 加入队列和集合中，这样我们就可以继续进行广度优先搜索。

如果我们最终无法到达终点，那么我们就返回 $-1$。

时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 是棋盘的边长。

<!-- tabs:start -->

#### Python3

```python
class Solution:
def snakesAndLadders(self, board: List[List[int]]) -> int:
def get(x):
i, j = (x - 1) // n, (x - 1) % n
if i & 1:
j = n - 1 - j
return n - 1 - i, j

n = len(board)
q = deque([1])
vis = {1}
ans = 0
m = n * n
while q:
for _ in range(len(q)):
curr = q.popleft()
if curr == n * n:
x = q.popleft()
if x == m:
return ans
for next in range(curr + 1, min(curr + 7, n * n + 1)):
i, j = get(next)
if board[i][j] != -1:
next = board[i][j]
if next not in vis:
q.append(next)
vis.add(next)
for y in range(x + 1, min(x + 6, m) + 1):
i, j = divmod(y - 1, n)
if i & 1:
j = n - j - 1
i = n - i - 1
z = y if board[i][j] == -1 else board[i][j]
if z not in vis:
vis.add(z)
q.append(z)
ans += 1
return -1
```
Expand All @@ -125,46 +134,35 @@ class Solution:

```java
class Solution {
private int n;

public int snakesAndLadders(int[][] board) {
n = board.length;
int n = board.length;
Deque<Integer> q = new ArrayDeque<>();
q.offer(1);
boolean[] vis = new boolean[n * n + 1];
int m = n * n;
boolean[] vis = new boolean[m + 1];
vis[1] = true;
int ans = 0;
while (!q.isEmpty()) {
for (int t = q.size(); t > 0; --t) {
int curr = q.poll();
if (curr == n * n) {
for (int ans = 0; !q.isEmpty(); ++ans) {
for (int k = q.size(); k > 0; --k) {
int x = q.poll();
if (x == m) {
return ans;
}
for (int k = curr + 1; k <= Math.min(curr + 6, n * n); ++k) {
int[] p = get(k);
int next = k;
int i = p[0], j = p[1];
if (board[i][j] != -1) {
next = board[i][j];
for (int y = x + 1; y <= Math.min(x + 6, m); ++y) {
int i = (y - 1) / n, j = (y - 1) % n;
if (i % 2 == 1) {
j = n - j - 1;
}
if (!vis[next]) {
vis[next] = true;
q.offer(next);
i = n - i - 1;
int z = board[i][j] == -1 ? y : board[i][j];
if (!vis[z]) {
vis[z] = true;
q.offer(z);
}
}
}
++ans;
}
return -1;
}

private int[] get(int x) {
int i = (x - 1) / n, j = (x - 1) % n;
if (i % 2 == 1) {
j = n - 1 - j;
}
return new int[] {n - 1 - i, j};
}
}
```

Expand All @@ -173,40 +171,36 @@ class Solution {
```cpp
class Solution {
public:
int n;

int snakesAndLadders(vector<vector<int>>& board) {
n = board.size();
int n = board.size();
queue<int> q{{1}};
vector<bool> vis(n * n + 1);
int m = n * n;
vector<bool> vis(m + 1);
vis[1] = true;
int ans = 0;
while (!q.empty()) {
for (int t = q.size(); t; --t) {
int curr = q.front();
if (curr == n * n) return ans;

for (int ans = 0; !q.empty(); ++ans) {
for (int k = q.size(); k > 0; --k) {
int x = q.front();
q.pop();
for (int k = curr + 1; k <= min(curr + 6, n * n); ++k) {
auto p = get(k);
int next = k;
int i = p[0], j = p[1];
if (board[i][j] != -1) next = board[i][j];
if (!vis[next]) {
vis[next] = true;
q.push(next);
if (x == m) {
return ans;
}
for (int y = x + 1; y <= min(x + 6, m); ++y) {
int i = (y - 1) / n, j = (y - 1) % n;
if (i % 2 == 1) {
j = n - j - 1;
}
i = n - i - 1;
int z = board[i][j] == -1 ? y : board[i][j];
if (!vis[z]) {
vis[z] = true;
q.push(z);
}
}
}
++ans;
}
return -1;
}

vector<int> get(int x) {
int i = (x - 1) / n, j = (x - 1) % n;
if (i % 2 == 1) j = n - 1 - j;
return {n - 1 - i, j};
}
};
```

Expand All @@ -215,43 +209,78 @@ public:
```go
func snakesAndLadders(board [][]int) int {
n := len(board)
get := func(x int) []int {
i, j := (x-1)/n, (x-1)%n
if i%2 == 1 {
j = n - 1 - j
}
return []int{n - 1 - i, j}
}
q := []int{1}
vis := make([]bool, n*n+1)
m := n * n
vis := make([]bool, m+1)
vis[1] = true
ans := 0
for len(q) > 0 {
for t := len(q); t > 0; t-- {
curr := q[0]
if curr == n*n {

for ans := 0; len(q) > 0; ans++ {
for k := len(q); k > 0; k-- {
x := q[0]
q = q[1:]
if x == m {
return ans
}
q = q[1:]
for k := curr + 1; k <= curr+6 && k <= n*n; k++ {
p := get(k)
next := k
i, j := p[0], p[1]
for y := x + 1; y <= min(x+6, m); y++ {
i, j := (y-1)/n, (y-1)%n
if i%2 == 1 {
j = n - j - 1
}
i = n - i - 1
z := y
if board[i][j] != -1 {
next = board[i][j]
z = board[i][j]
}
if !vis[next] {
vis[next] = true
q = append(q, next)
if !vis[z] {
vis[z] = true
q = append(q, z)
}
}
}
ans++
}
return -1
}
```

#### TypeScript

```ts
function snakesAndLadders(board: number[][]): number {
const n = board.length;
const q: number[] = [1];
const m = n * n;
const vis: boolean[] = Array(m + 1).fill(false);
vis[1] = true;

for (let ans = 0; q.length > 0; ans++) {
const nq: number[] = [];
for (const x of q) {
if (x === m) {
return ans;
}
for (let y = x + 1; y <= Math.min(x + 6, m); y++) {
let i = Math.floor((y - 1) / n);
let j = (y - 1) % n;
if (i % 2 === 1) {
j = n - j - 1;
}
i = n - i - 1;
const z = board[i][j] === -1 ? y : board[i][j];
if (!vis[z]) {
vis[z] = true;
nq.push(z);
}
}
}
q.length = 0;
for (const x of nq) {
q.push(x);
}
}
return -1;
}
```

<!-- tabs:end -->

<!-- solution:end -->
Expand Down
Loading
Loading