力扣——滑动谜题

在一个 2 x 3 的板上（board）有 5 块砖瓦，用数字 1~5 来表示, 以及一块空缺用 0 来表示.

一次移动定义为选择 0 与一个相邻的数字（上下左右）进行交换.

最终当板 board 的结果是 [[1,2,3],[4,5,0]] 谜板被解开。

给出一个谜板的初始状态，返回最少可以通过多少次移动解开谜板，如果不能解开谜板，则返回 -1 。

示例：

输入：board = [[1,2,3],[4,0,5]]
输出：1
解释：交换 0 和 5 ，1 步完成

输入：board = [[1,2,3],[5,4,0]]
输出：-1
解释：没有办法完成谜板

输入：board = [[4,1,2],[5,0,3]]
输出：5
解释：
最少完成谜板的最少移动次数是 5 ，
一种移动路径:
尚未移动: [[4,1,2],[5,0,3]]
移动 1 次: [[4,1,2],[0,5,3]]
移动 2 次: [[0,1,2],[4,5,3]]
移动 3 次: [[1,0,2],[4,5,3]]
移动 4 次: [[1,2,0],[4,5,3]]
移动 5 次: [[1,2,3],[4,5,0]]

输入：board = [[3,2,4],[1,5,0]]
输出：14

提示：

• board 是一个如上所述的 2 x 3 的数组.
• board[i][j] 是一个 [0, 1, 2, 3, 4, 5] 的排列.

class Solution {
public int slidingPuzzle(int[][] board) {
    int r1 = 123450;
    int r2 = 123540;
    int b = 0;
    for (int[] i : board) {
        for (int j : i) {
            b = b * 10 + j;
        }
    }
    Queue<Integer> q = new ArrayDeque<>();
    Set<Integer> set = new HashSet<>();
    q.add(b);
    int k = 0;
    while (!q.isEmpty()) {
        int p = q.poll();
        k = p / 1000000;
        int t = p % 1000000;
        if (t == r2) {
            return -1;
        }
        if (t == r1) {
            return k;
        }
        int i = 6;
        int tt = t;
        while (tt / 10 * 10 != tt) {
            tt = tt / 10;
            i--;
        }
        switch (i) {
            case 6: {
                int newp = t - t % 10000 + t % 1000 + t % 10000 / 1000;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                newp =  t - t % 100 + t % 100 / 10;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                break;
            }
            case 5: {
                int newp = t - t / 10000 % 10 * 9990;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                newp =  t - t / 100 % 10 * 90;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                newp = t + t % 10 * 9;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                break;
            }
            case 4: {
                int newp = t - t / 100000 * 99900;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                newp = t + t / 10 % 10 * 90;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                break;
            }
            case 3: {
                int newp = t - t % 100000 + t % 1000 + t % 100000 / 10000 * 1000;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                newp =  t - t % 10 + t % 10 * 1000;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                break;
            }
            case 2: {
                int newp =  t - t / 100000 * 90000;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                newp = t + t % 10000 / 1000 * 9000;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                newp =  t + t % 100 / 10 * 9990;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                break;
            }
            case 1: {
                int newp =  t + t / 10000 * 90000;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                newp =  t - t / 100 % 10 * 100 + t / 100 % 10 * 100000;
                if(!set.contains(newp)) {
                    set.add(newp);
                    q.add((k + 1) * 1000000 + newp);
                }
                break;
            }
        }
    }
    return -1;
}
}