LeeCode 773 滑动谜题

在一个 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] 的排列.

---

这道题可以将每一个状态的broad 用一个六位数p表示，再将滑动次数 * 1000000加上p记为一个状态，用p的不同判断状态的不同，然后用bfs即可：

//773 -- 13ms -- 80.00%
    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;
    }