題目地址：

https://www.lintcode.com/problem/snakes-and-ladders/description

給定一個$N\times N$棋盤$A$，對每個格子進行編號，從最左下角開始從$1$編號，向右依次$2,3,...,N$，走到最右邊則向上走一步是$N+1$，然後一路再向左依次是$N+2,N+3,...,2N$，這樣走到第$0$行直至走到$N^2$這個位置。從編號$1$的位置出發，每次處於$a$的時候，可以走到$a+j,j=1,2,...,6$這些位置（當然這些位置的編號不能超出$N^2$），如果$A$在這個位置不等於$-1$，那麼就需要瞬間移動到$A$在此處的值對應的編號的位置（瞬移是強制的，不消耗步數）。問從$1$出發至少需要走多少步能走到$N^2$這個位置。題目保證$A[N-1][0]=-1$，並且$N>1$。

思路是BFS。我們可以直接視為是在一維陣列上操作的，問題的關鍵在於怎麼將一維陣列的下標轉化為二維陣列。如果某個位置在一維陣列中的下標是$i$，那麼其在二維陣列中的行座標應該是$x=N-1-\lfloor i/N\rfloor$，而列座標則需要取決於$N-1-x$的奇偶性，如果$N-1-x$是偶數，則是從左到右的，那麼列座標就是$i\%N$，否則則是$N-1-i\%N$。程式碼如下：

import java.util.ArrayDeque;
import java.util.Queue;

public class Solution {
    /**
     * @param board: board
     * @return: snakesAndLadders
     */
    public int snakesAndLadders(int[][] board) {
        // write your code here
        int n = board.length;
        int start = 0, end = n * n - 1;
        Queue<Integer> queue = new ArrayDeque<>();
        queue.offer(start);
        boolean[] visited = new boolean[n * n];
        visited[0] = true;
        
        int res = 0;
        while (!queue.isEmpty()) {
        	// 走一步
            res++;
            // 由於是分層BFS，需要記錄佇列size
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int cur = queue.poll();
                for (int j = 1; j <= 6 && cur + j < n * n; j++) {
                    int next = cur + j;
                    int[] trans = transfer(next, n);
                    // 如果能瞬移則需要瞬移
                    if (board[trans[0]][trans[1]] != -1) {
                        next = board[trans[0]][trans[1]] - 1;
                    }
                    
                    // 走到終點了，返回步數
                    if (next == end) {
                        return res;
                    }
                    
                    if (!visited[next]) {
                        queue.offer(next);
                        visited[next] = true;
                    }
                }
            }
        }
        
        return -1;
    }
    
    private int[] transfer(int idx, int n) {
        int x = n - 1 - idx / n;
        int y = (n - 1 - x) % 2 == 0 ? idx % n : n - 1 - idx % n;
        return new int[]{x, y};
    }
}

時空複雜度$O(N^2)$。