HDU1043 Eight(BFS)

　　Eight(South Central USA 1998)

Time Limit:5000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u

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

 

题目简单翻译：

八数码

给你一个八数码：（格式是一个九宫格，x代表空），问怎么操作能达到目标，即：

1 2 3

4 5 6

7 8 x

u代表空格向上交换，d代表空格向下交换，l代表空格向左交换，r代表空格向右交换。

例如：

给你一个八数码：

1 2 3

x 4 6

7 5 8

则把它变成目标需要三步：

1 2 3　　　r　 　1 2 3　　　d　　　1 2 3　　r　　　1 2 3

x 4 6　　--->　　4 x 6　　--->　　4 5 6　　--->　　4 5 6

7 5 8　　　　　　7 5 8　　　　　　7 x 8　　　　　　7 8 x

所以这个样例应该输出：

rdr

如果不能到达目标就输出“unsolvable”.

 

解题思路：广度优先搜索（BFS）

因为是多组数据，我们可以先求出所有情况，然后每次询问的时候直接输出结果就好了。

求出所有结果，我们就可以根据结果，来逆向bfs，直到所有的情况都求到。

 

代码：

 #include<cstdio>
 #include<string>
 #include<queue>
 #include<cstring>
 using namespace std;
 struct node
 {
     int t[][],x,y,Can;
     int Last_Can,dir;
 } St[];
 int fac[]= {,,,,,,,,};
 //康托展开的数组
 //康托展开就是把一组数据按照字典序排列的那组数据的序号

 int vis[];
 queue<int> Q;
 char dr[]="rlud";
 int  dx[]= {,,,-};
 int  dy[]= {-,,,};
 //方向数组，与实际的方向相反，因为是逆向操作
 int Cantor(int *t)//对一组数据求康拓值
 {
     int rev=;
     for(int i=; i<; i++)
     {
         int counted=;
         for(int j=i+; j<; j++)
             if(t[i]>t[j]) counted++;
         rev+=counted*fac[-i];
     }
     return rev;
 }
 bool check(int x,int y) //检查这个点是不是在矩形内
 {
     return x>=&&x<&&y>=&&y<;
 }
 void solve()//bfs求出所有的情况，并储存下来父节点
 {
     while(!Q.empty()) Q.pop();
     node st;
     st.x=st.y=;
     int s[][]= {,,,,,,,,};
     int t[];
     for(int i=; i<; i++)
         for(int j=; j<; j++)
             t[i*+j]=s[i][j];
     for(int i=; i<; i++)
         for(int j=; j<; j++)
             st.t[i][j]=s[i][j];
     int StCan=Cantor(t);
     st.Can=StCan;
     st.Last_Can=-;
     st.dir=-;
     memset(vis,,sizeof vis);
     vis[StCan]=;
     St[StCan]=st;
     Q.push(StCan);
     int Sum=;
     while(!Q.empty())
     {
         Sum++;
         int TempCan=Q.front();
         Q.pop();
         for(int i=; i<; i++)
         {
             node e=St[TempCan];
             int curx=e.x+dx[i];
             int cury=e.y+dy[i];
             if(check(curx,cury))
             {
                 int c=e.t[curx][cury];
                 e.t[curx][cury]=e.t[e.x][e.y];
                 e.t[e.x][e.y]=c;
                 e.x=curx;
                 e.y=cury;
                 int t[];
                 for(int i=; i<; i++)
                     for(int j=; j<; j++)
                         t[i*+j]=e.t[i][j];
                 e.Can=Cantor(t);
                 e.Last_Can=TempCan;
                 e.dir=i;
                 if(!vis[e.Can])
                 {
                     vis[e.Can]=;
                     St[e.Can]=e;
                     Q.push(e.Can);
                 }
             }
         }
     }
 }
 int main()
 {
     char c[];
     int t[],x=;
     solve();
     while(scanf("%s",c)!=EOF)
     {
         if(c[]=='x') c[]='';
         t[]=c[]-'';
         for(int i=;i<;i++)
         {
             scanf("%s",c);
             if(c[]=='x') c[]='';
             t[i]=c[]-'';
         }
         int AnsCan=Cantor(t);
         if(vis[AnsCan])
         {
             int p=AnsCan;
             while(St[p].Last_Can+)
             {
                 printf("%c",dr[St[p].dir]);
                 p=St[p].Last_Can;
             }
             printf("\n");
         }
         else
             printf("unsolvable\n");
     }
     return ;
 }

Eight