hdu1043Eight (经典的八数码)（康托展开+BFS）

Eight

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 39590 Accepted Submission(s): 10101
Special Judge

Problem Description

The 15-puzzle has been around for over 100 years; even if you don’t know it by that name, you’ve seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and all packed into a 4 by 4 frame with one tile missing. Let’s call the missing tile ‘x’; the object of the puzzle is to arrange the tiles so that they are ordered as:

1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 x

where the only legal operation is to exchange ‘x’ with one of the tiles with which it shares an edge. As an example, the following sequence of moves solves a slightly scrambled puzzle:

 1  2  3  4     1  2  3  4     1  2  3  4     1  2  3  4
 5  6  7  8     5  6  7  8     5  6  7  8     5  6  7  8
 9  x  10 12    9 10  x 12     9 10 11 12     9 10 11 12
 13 14 11 15    13 14 11 15    13 14  x 15    13 14 15  x
    r->            d->            r->

The letters in the previous row indicate which neighbor of the ‘x’ tile is swapped with the ‘x’ tile at each step; legal values are ‘r’,‘l’,‘u’ and ‘d’, for right, left, up, and down, respectively.

Not all puzzles can be solved; in 1870, a man named Sam Loyd was famous for distributing an unsolvable version of the puzzle, and
frustrating many people. In fact, all you have to do to make a regular puzzle into an unsolvable one is to swap two tiles (not counting the missing ‘x’ tile, of course).

In this problem, you will write a program for solving the less well-known 8-puzzle, composed of tiles on a three by three
arrangement.

Input

You will receive, several descriptions of configuration of the 8 puzzle. One description is just a list of the tiles in their initial positions, with the rows listed from top to bottom, and the tiles listed from left to right within a row, where the tiles are represented by numbers 1 to 8, plus ‘x’. For example, this puzzle

1 2 3
x 4 6
7 5 8

is described by this list:

1 2 3 x 4 6 7 5 8

Output

You will print to standard output either the word ``unsolvable’’, if the puzzle has no solution, or a string consisting entirely of the letters ‘r’, ‘l’, ‘u’ and ‘d’ that describes a series of moves that produce a solution. The string should include no spaces and start at the beginning of the line. Do not print a blank line between cases.

Sample Input

2 3 4 1 5 x 7 6 8

Sample Output

ullddrurdllurdruldr

//康托展开+BFS
import java.util.*;
public class Main {
   public static int H[]=new int [12];
   public static int p[][]= {{1,0},{-1,0},{0,1},{0,-1}};
   public static String Ps[]= {"u","d","l","r"};
   public static boolean vis[]=new boolean [1000000];
   public static String M[]=new String [1000000];
   public static int JSQ=0;
   public static int getH(int str[]) {  //康托展开
	   int ans=0;
	   for(int i=0;i<str.length;i++)
	   {
		   int num=0;
		   for(int j=i+1;j<str.length;j++)
		   {
			   if(str[j]<str[i]) {
				   num++;
			   }
		   }
		   ans+=(num*H[9-i-1]);
	   }
	   return ans+1;
   }
   public static void bfs() {
	   Queue<HDUN>QUE = new LinkedList<HDUN>();
	   HDUN F=new HDUN();
	   for(int i=0;i<9;i++)
		   F.a[i]=(i+1);
	       F.a[8]=0;
	       F.step="";
	       F.Hval=46234;
	       F.index=8;
	       M[F.Hval]="";
	       QUE.offer(F);
//	       vis[F.Hval]=true;
	   while(!QUE.isEmpty()) {
		   HDUN A=QUE.poll();
		   int x=A.index/3;
		   int y=A.index%3;
		   for(int i=0;i<4;i++)
		   {
			   int xx=x+p[i][0];
			   int yy=y+p[i][1];
			   if(xx>=0&&yy>=0&&xx<3&&yy<3)
			   {
				   HDUN next=new HDUN();
				   next.index=xx*3+yy;
				   for(int ii=0;ii<9;ii++)
					   next.a[ii]=A.a[ii];
		
				   next.a[A.index]=next.a[next.index];
				   next.a[next.index]=0;
				   next.Hval=getH(next.a);
				   if(!vis[next.Hval])
				   {
					   
					    JSQ++;
					   vis[next.Hval]=true;
					   next.step=Ps[i]+A.step;
					   M[next.Hval]=next.step;
					   QUE.offer(next);
				   }
			   }
		   }
	   }
   }
   public static void main(String[] args) {
	Scanner sc=new Scanner(System.in);
	H[0]=1;
	for(int i=1;i<=10;i++)
		H[i]=H[i-1]*(i);
	bfs();
	while(sc.hasNext())
	{
		String str=sc.nextLine();
		String Str[]=str.split("\\s+");
		int start[]=new int [9];
		for(int i=0;i<Str.length;i++) {
		    if(Str[i].equals("x"))
			start[i]=0;
		    else
		    start[i]=Integer.valueOf(Str[i]);
		}
		if(M[getH(start)]!=null)
		System.out.println(M[getH(start)]);
		else
	    System.out.println("unsolvable");
	}
}
}
 class HDUN{
	String step;
	int a[]=new int [9];
	int index,Hval;
}