九宫重排_康拓展开_bfs

  历届试题 九宫重排  

时间限制：1.0s   内存限制：256.0MB

      

问题描述

　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。

　　我们把第一个图的局面记为：12345678.
　　把第二个图的局面记为：123.46758
　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。
　　本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出-1。

输入格式

　　输入第一行包含九宫的初态，第二行包含九宫的终态。

输出格式

　　输出最少的步数，如果不存在方案，则输出-1。

样例输入

12345678.
123.46758

样例输出

3

样例输入

13524678.
46758123.

样例输出

22

 

 

拿到这个题的时候没什么思路，之前也做过bfs的题，最大的问题在于状态的保存，后来看到有个编码题用到了康拓展开，豁然开朗，数学真的是奇妙啊！还有很多不知道的东西呢！

又知道了java的几个坑，哪怕是数组直接赋值也是赋的地址，添加到链表之类的也是地址，想要不受干扰只能手工拷贝。

 package study_code;

 import java.util.LinkedList;
 import java.util.Queue;
 import java.util.Scanner;

 public class 八数码 {

     static int[] vis = new int [900900]; //判断哈希值是否被访问
     static int[] f = new int[9];    //保存阶乘
     static int end; //最终状态的哈希值
     static node start = new node();
     static String resPath;
     static int[][] dir = {{-1,0},{1,0},{0,-1},{0,1}};
     static char[] dirc = {'U','D','L','R'};
     static class node{
         int loc; //记录当前空格位置 用一个数字记录 1-9
         int s[]; //记录当前所有数字的位置
         int hashVal; //当前状态的哈希值
         String path = ""; //记录当前路径
         public node() {
         }
     }

     public static void fac() {
         f[0] = 1;
         for (int i = 1; i < f.length; i++) {
             f[i] = f[i-1] * i;
         }
     }

     //康拓展开
     public static int getHash(int[] s) {
         int res = 0;
         for (int i = 0; i < s.length; i++) {
             int index =0;
             for (int j = i+1; j < s.length; j++) {
                 if (s[j]<s[i]) {
                     index++;
                 }
             }
             res += index*f[9-1-i];
         }
         return res;
     }

     public static boolean bfs() {
         Queue<node> q = new LinkedList<node>();
         q.offer(start);
         vis[start.hashVal] = 1;
         while (!q.isEmpty()) {
             node cur = q.poll();
             vis[cur.hashVal] = 1;
             if (cur.hashVal == end) {
                 resPath = cur.path;
                 return true;
             }
             int x =cur.loc/3;
             int y =cur.loc%3;
             for (int i = 0; i < 4; i++) {
                 int tx = x + dir[i][0];
                 int ty = y + dir[i][1];
                 if (tx<0||ty<0||tx>=3||ty>=3) {
                     continue;
                 }
                 node temp = new node();
                 temp.loc = tx*3+ty;
                 temp.path = cur.path+dirc[i];
                 temp.s = cur.s.clone();
                 //交换空格的位置
                 temp.s[cur.loc] = temp.s[temp.loc];
                 temp.s[temp.loc] = 0;

                 temp.hashVal = getHash(temp.s);
                 if (vis[temp.hashVal] == 1) {
                     continue;
                 }
                 q.offer(temp);
                 vis[temp.hashVal] = 1;
             }
         }
         return false;

     }
     public static void main(String[] args) {
         Scanner sc = new Scanner(System.in);
         fac();
         String t = sc.nextLine();
         char[] c = t.toCharArray();
         int[] n = new int[c.length];
         for (int i = 0; i < c.length; i++) {
             if (c[i] == '.') {
                 n[i] = 0;
                 start.loc = i;
             }else {
                 n[i] = c[i] - '0';
             }
         }
         start.s = n.clone();
         start.hashVal = getHash(start.s);
         t = sc.nextLine();
         c = t.toCharArray();
         n = new int[c.length];
         for (int i = 0; i < c.length; i++) {
             if (c[i] == '.') {
                 n[i] = 0;
             }else {
                 n[i] = c[i] - '0';
             }
         }
         end = getHash(n);
         bfs();
         System.out.println(resPath.length());
     }
 }