八数码问题（BFS）

问题描述

    在一个3*3的的棋盘上放置编号为1~8的8个方块，每个占据一格，另外还有一个空格。与空格相邻的数字方块可以移动到空格里。指定初始棋局和目标棋局（如下图），计算出最少的移动步数
    把空格看成0，一共九个数字

    输入样例：
    1 2 3 0 8 4 7 6 5
    1 0 3 8 2 4 7 6 5
    输出样例：
    2

要点
    主要掌握 广度优先搜索（BFS）的方法

解题思路

    把一个棋局看成一个状态图，总共有 9！=362880 个状态。从初始棋局开始，每次移动转到下一个状态，到达目标棋局后停止。
    八数码从最初状态出发，每次转移都逐步逼近目标状态。每转移一次，步数加一，当达到目标时，经过的步数就是最短路径。
    下图就是样例的转移过程。该图中起点为（A,0)，A表示状态，即{1 2 3 0 8 4 7 6 5}这个棋局，0是距离起点的步数

    用队列描述这个BFS过程：
    (1) A 进队，当前队列是{A}；
    (2) A 出队，A 的邻居 B、C、D进队，当前队列是{B, C, D}，步数为1；
    (3) B 出队，E 进队，当前队列是{C, D, E}，E 的步数为2；
    (4) C 出队，转移到 F，检验 F 是目标状态，停止，输出 F 的步数为2。

    仔细分析上述过程，发现从 B 状态出发实际上有 E 、X 两个转移方向，而 X 正好是初始状态 A ，重复了。同理 Y 也是重复的。如果 不去掉这些重复的状态，程序会产生很多无效的操作，复杂度大大增加。因此，八数码最重要的问题是判重。
    本题使用数学方法“康托展开（Cantor Expansion）”来判重

康托展开

    例子：判断 2143 是{1，2，3，4}的全排列中第几大的数
    计算排在 2143 前面的排列数目，可以将问题转换为以下排列的和：
    （1）首位小于 2 的所有排列。比 2 小的只有 1 一个数，后面 3 个数的排列有 3 * 2 * 1 = 3！个（即 1234,1243,1324,1342,1423,1432），写成 1 * 3！= 6；
    （2）首位为 2 、第二位小于 1 的所有排列。无，写成 0 * 2！= 0；
    （3）前两位为 21 、第三位小于 4 的所有排列。只有 3 一个数（即 2134），写成 1 * 1! = 1;
    （4）前三位为 214、第四位小于 3 的所有排列。无，写成 0 * 0！= 0；
    求和：1 * 3！+ 0 * 2！+ 1 * 1！+ 0 * 0！ = 7，所以2143 是全排列中第 8 大的数。如果用 int visited[24] 数组记录各排列的位置，{2143}就是visited[7]；第一次访问这个排列时，置 visited[7]=1，当再次访问这个排列的时候发现 visited[7]=1，说明已经处理过了，判重。
    根据上述例子得到康托展开式

    下面用“ BFS + Cantor ”解决八数码问题

代码如下(Java)

import java.util.*;

public class Main
{
    final int LEN = 362880;    //状态共 9！= 362880 种
    int[][] dir = {{-1,0},{0,-1},{1,0},{0,1}};  //左，上，右，下顺时针方向，左上角的坐标是（0,0）
    int[] visited = new int[LEN];  //与每个状态对应的记录，Cantor()方法对它置数（初始均为0），并判重
    int[] start = new int[9];  //最开始状态
    int[] goal = new int[9];   //目标状态
    long[] factory = {1,1,2,6,24,120,720,5040,40320,362880};   //Cantor()方法用到的常数

    boolean Cantor(int str[], int n){   //用康托展开判重
        long result = 0;
        for(int i=0; i<n; i++){
            int counted = 0;
            for(int j=i+1; j<n; j++){
                if(str[i] > str[j]){   //当前未出现的元素排在第几个
                    counted++;
                }
            }
            result += counted * factory[n-i-1];
        }
        if(visited[(int) result] == 0){ //没有被访问过
            visited[(int) result] = 1;
            return true;
        }
        else return false;
    }

    int bfs(){
        Node head = new Node();
        head.arr = copy(start);   //复制起点的状态
        head.dis = 0;
        Queue<Node> q = new LinkedList<>();   //队列中的内容是记录状态
        Cantor(head.arr,9);   //用康托展开判重，目的是对起点的 visited[] 赋初值
        q.add(head);   //第一个进入队列的是起点状态

        while(!q.isEmpty()){  //处理队列
            head = q.poll(); //可在此处打印 head.arr，看弹出的队列情况
            int z;
            for(z=0; z<9; z++){   //找到队列中元素0的位置
                if(head.arr[z] == 0){   //找到了
                    break;
                }
            }   //转化为二维，左上角是原点
            int x = z % 3;   //横坐标
            int y = z / 3;   //纵坐标
            for(int i=0; i<4; i++){   //判断向上，下，左，右移动后的状态，最多4种新状态
                int newx = x + dir[i][0];   //元素0转移后的新坐标
                int newy = y + dir[i][1];
                int nz = newx + 3*newy;   //转化为一维
                if(newx>=0 && newx<3 && newy>=0 && newy<3){ //未越界
                    Node newnode = new Node();
                    newnode.arr = copy(head.arr);
                    newnode.dis = head.dis;   //连同上一步，是进行复制新状态的操作
                    change(newnode.arr, z, nz);   //把0移到新的位置
                    newnode.dis++;
                    if(Arrays.equals(newnode.arr, goal)){   //与目标状态对比
                        return newnode.dis;   //达到目标状态，返回距离，结束
                    }
                    if(Cantor(newnode.arr, 9)){   //用康托展开判重
                        q.add(newnode);   //把新的状态放进队列
                    }
                }
            }
        }
        return -1;   //没找到，无法达到目标状态
    }

    private int[] copy(int[] arr){   //复制数组
        int[] arr2 = new int[9];
        for(int i=0; i < arr.length; i++){
            arr2[i] = arr[i];
        }
        return arr2;
    }

    private void change(int[] arr, int pos, int newPos){   //交换变量值
        arr[pos] = arr[pos] ^ arr[newPos];
        arr[newPos] = arr[pos] ^ arr[newPos];
        arr[pos] = arr[pos] ^ arr[newPos];   //此种交换变量的方法仅适用于整数
       /* int t = arr[pos];
        arr[pos] = arr[newPos];
        arr[newPos] = t;*/
    }

    public static void main(String args[]){
        Main m = new Main();
        Scanner sc = new Scanner(System.in);
        for(int i=0; i<9; i++)
            m.start[i] = sc.nextInt();   //初始状态
        for(int i=0; i<9; i++)
            m.goal[i] = sc.nextInt();   //目标状态
        int num = m.bfs();
        System.out.println(num == -1 ? "Impossible" : num);
    }
}
class Node{   
    public int[] arr = new int[9];   //记录一个八数码的排列，即一个状态
    public int dis;   //记录到起点的距离
}