2.隐式图的搜索问题

题目2：隐式图的搜索问题

实验内容

对九宫重排问题，建立图的启发式搜索求解方法；
用A*算法求解九宫重排问题。

实验要求

3х3九宫棋盘，放置数码为1~8的8个棋子，棋盘中留有一个空格，空格周围的棋子可以移动到空格中，从而改变棋盘的布局。根据给定初始布局和目标布局，移动棋子从初始布局到达目标布局，求解移动步骤并输出。请设计算法，使用合适的搜索策略，在较少的空间和时间代价下找到最短路径。

编程语言

编程语言：Java
编译环境：JDK12
开发工具：IntelliJ IDEA

项目思路

（1）1-8八个数字随机分布在一个九宫格内
（2）九宫格内存在一个无数字格（空格），可用#代替
（3）空格周围的几个数字都可与空格互换位置
（4）经过多次互换，使得空格位于九宫格重要，数字1-8从左上角宫格开 始，顺时针依次排布
（5）从初始状态经过多次互换达到最终状态有无数种可能，求最优算法

算法选择

A*算法
A* 算法，A*(A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。 注意——是最有效的直接搜索算法，之后涌现了很多预处理算法(如ALT，CH，HL等等)，在线查询效率是A*算法的数千甚至上万倍。 公式表示为：f(n)=g(n)+h(n), 其中， f(n) 是从初始状态经由状态n到目标状态的代价估计， g(n)是在状态空间中从初始状态到状态n的实际代价， h(n) 是从状态n到目标状态的最佳路径的估计代价。 (对于路径搜索问题，状态就是图中的节点，代价就是距离) h(n)的选取保证找到最短路径(最优解的)条件，关键在于估价函数f(n)的选取(或者说h(n)的选取)。 我们以d(n)表达状态n到目标状态的距离，那么h(n)的选取大致有如下三种情况: （1）如果h(n)<d(n)到目标状态的实际距离，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。 （2）如果h(n)=d(n)，即距离估计h(n)等于最短距离，那么搜索将严格沿着最短路径进行， 此时的搜索效率是最高的。 （3）如果h(n)>d(n)，搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。

public static int A_star(int[][] MT) {
        // 找到空格所在的位置
        int x0 = 0, y0 = 0;
        for (x0 = 0; x0 < N; x0++) {
            boolean flag = false;
            for (y0 = 0; y0 < N; y0++) {
                if (MT[x0][y0] == 0) {
                    flag = true;
                    break;
                }
            }
            if (flag)
                break;
        }
        // 优先队列
        Queue<node> q = new PriorityQueue<node>(cmp);
        int[][] curmt = new int[N][];
        int[][] markemt = new int[N][];
        // clone方法用于复制一个对象，在内存中开辟同样大小的空间
        for (int r = 0; r < N; r++)
            curmt[r] = MT[r].clone();
        for (int r = 0; r < N; r++)
            markemt[r] = MT[r].clone();
        List<int[][]> path = new ArrayList<int[][]>();
        // path加入初始状态
        path.add(MT);
        // 创建一个结点，表示空格，估价函数初始化为0
        node cur = new node(x0, y0, 0, 0, 0, curmt, path);
        // 将出现过的所有状态都加入marke集合中
        marke.add(markemt);
        // 入队并遍历
        q.add(cur);
        while (!q.isEmpty()) {
            // 队首元素出队
            cur = (node) q.poll().clone();
            boolean tag = false;
            // 判断当前状态是不是目标状态
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    if (cur.mt[i][j] != endMT[i][j]) {
                        tag = true;
                    }
                }
            }
            // 如果是，输出结果
            if (!tag) {
                System.out.println("共扩展了" + marke.size() + "个结点");
                return cur.step;
            }
            // 遍历四种方向上的移动
            for (int i = 0; i < 4; i++) {
                node next = (node) cur.clone();
                next.x = cur.x + dir[i][0];
                next.y = cur.y + dir[i][1];
                // 如果空格位置不合法就忽略这个状态
                if (next.x >= 0 && next.x < N && next.y >= 0 && next.y < N) {
                    // 因为上面next定义时clone了cur，所以在这里更新空格的位置
                    next.mt[cur.x][cur.y] = next.mt[next.x][next.y];
                    next.mt[next.x][next.y] = 0;
                    boolean mark = false;
                    // 判断当前状态有没有出现过
                    for (int c = 0; c < marke.size(); c++) {
                        int x = 0, y = 0;
                        for (x = 0; x < N; x++) {
                            for (y = 0; y < N; y++)
                                if (marke.get(c)[x][y] != next.mt[x][y])
                                    break;
                            if (y < N)
                                break;
                        }
                        if (x == N && y == N)
                            mark = true;
                    }
                    // 若出现过则忽略这个状态
                    if (!mark) {
                        // 更新next的属性值step和估价函数g
                        next.step++;
                        next.g++;
                        // 将当前状态加入到结点的path中，因为程序中定义结点时，clone了上一个结点，所以在当前结点添加的状态也会clone到下一个结点中。
                        next.path.add(next.mt);
                        // 计算估价函数h，获取每个位置的数字，到达目标状态中对应数字的位置，所需要的步数
                        int count = 0;
                        for (int row = 0; row < N; row++) {
                            for (int cow = 0; cow < N; cow++) {
                                if (cow != 0 && next.mt[row][cow] != endMT[row][cow]) {
                                    count += Math.abs(row - map.get(next.mt[row][cow])[0])
                                            + Math.abs(cow - map.get(next.mt[row][cow])[1]);
                                }
                            }
                        }
                        next.h = count;
                        // 将扩展状态入队
                        int[][] newmt = new int[N][];
                        for (int r = 0; r < N; r++)
                            newmt[r] = next.mt[r].clone();
                        marke.add(newmt);
                        q.add((node) next.clone());
                    }
                }
            }
        }
        return 0;
    }