【Lintcode】1732. Snakes and Ladders

题目地址：

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)$。