【HDOJ1043】【康拓展开+BFS】

http://acm.hdu.edu.cn/showproblem.php?pid=1043

Eight

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 30907    Accepted Submission(s): 8122
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

题解：裸的康拓展开

使用康拓展开对全排列进行hash，然后使用bfs从末状态开始跑，跑到的状态都是有解的状态，否则输入的初状态无解，在bfs过程记录这一步的下一步即可。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<queue>
 using namespace std;
 int qwq[];
 char sss[];
 int vv[];
 bool v[];
 int f0;
 int counter(string s){
     int sum=;
     for(int i=;i<=;i++){
         qwq[i]=qwq[i-]*i;
     }
     for(int i=;i<;i++){
         int tt=;
         for(int j=i+;j<;j++){
             if(s[j]<s[i]){
                 tt++;
             }
         }
         sum+=qwq[-i]*tt;
     }
     return sum;
 }
 queue<string>pq;
 void bfs(){
     while(!pq.empty())pq.pop();
     string s0="";
     pq.push(s0);
     f0=counter(s0);
     v[f0]=;
     while(!pq.empty()){
         string aa=pq.front();pq.pop();
         int fs=counter(aa);
        //if(fs==76346)cout <<aa<<endl;
         for(int i=;i<aa.size();i++){
             if(aa[i]==''){
                 if(i%==){
                     string bb=aa;
                     bb[i]=bb[i+];
                     bb[i+]='';
                     int f=counter(bb);
                     if(!v[f]){
                         v[f]=;
                         sss[f]='l';
                         vv[f]=fs;
                         pq.push(bb);
                     }
                     if(i!=){
                         string cc=aa;
                         cc[i]=cc[i+];
                         cc[i+]='';
                         int f=counter(cc);
                         if(!v[f]){
                             v[f]=;
                             vv[f]=fs;
                             sss[f]='u';
                             pq.push(cc);
                         }
                     }
                     if(i!=){
                         string dd=aa;
                         dd[i]=dd[i-];
                         dd[i-]='';
                         int f=counter(dd);
                         if(!v[f]){
                             v[f]=;
                             vv[f]=fs;
                             sss[f]='d';
                             pq.push(dd);
                         }
                     }
                 }
                 else if(i%==){
                      string bb=aa;
                     bb[i]=bb[i+];
                     bb[i+]='';
                     int f=counter(bb);
                     if(!v[f]){
                         v[f]=;
                         vv[f]=fs;
                         sss[f]='l';
                         pq.push(bb);
                     }
                      string cc=aa;
                     cc[i]=cc[i-];
                     cc[i-]='';
                     f=counter(cc);
                     if(!v[f]){
                         v[f]=;
                         vv[f]=fs;
                         sss[f]='r';
                         pq.push(cc);
                     }
                     if(i!=){
                          string cc=aa;
                         cc[i]=cc[i+];
                         cc[i+]='';
                         int f=counter(cc);
                         if(!v[f]){
                             v[f]=;
                             vv[f]=fs;
                             sss[f]='u';
                             pq.push(cc);
                         }

                     }
                     if(i!=){
                         string dd=aa;
                         dd[i]=dd[i-];
                         dd[i-]='';
                         int f=counter(dd);
                         if(!v[f]){
                             v[f]=;
                             vv[f]=fs;
                             sss[f]='d';
                             pq.push(dd);
                         }
                     }
                 }
                 else{
                      string bb=aa;
                     bb[i]=bb[i-];
                     bb[i-]='';

                     int f=counter(bb);
                    // if(fs==76346)
                    //cout <<f<<"  "<<endl;
                     if(!v[f]){
                         v[f]=;
                         vv[f]=fs;
                         sss[f]='r';
                         pq.push(bb);
                     }
                     if(i!=){
                         string cc=aa;
                         cc[i]=cc[i+];
                         cc[i+]='';
                         int f=counter(cc);

                         if(!v[f]){
                             v[f]=;
                             vv[f]=fs;
                             sss[f]='u';
                             pq.push(cc);
                         }
                     }
                     if(i!=){
                         string dd=aa;
                         dd[i]=dd[i-];
                         dd[i-]='';
                         int f=counter(dd);
                         if(!v[f]){
                             v[f]=;
                             vv[f]=fs;
                             sss[f]='d';
                             pq.push(dd);
                         }
                     }
                 }
             }
         }
     }
 }
 void init(){
     qwq[]=qwq[]=;
     for(int i=;i<=;i++){
         qwq[i]=qwq[i-]*i;
     }
 }
 int main(){
     init();
     bfs();
     char aa[];
     char bb[];
     //while(scanf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",aa[0],aa[1],aa[2],aa[3],aa[4],aa[5],
      //           aa[6],&aa[7],&aa[8],)){
     while(gets(aa)){
         if(aa[]=='\0')break;
         int tot=;
         int len=strlen(aa);
         for(int i=;i<len;i++){
             if((aa[i]>=''&&aa[i]<='')){
                 bb[tot++]=aa[i];
             }
             if(aa[i]=='x'){
                 bb[tot++]='';
             }
         }
         bb[tot]='\0';
         int f=counter(bb);
        // cout << f<<"   "<<bb<<endl;
         //cout <<f<<endl;46103
         if(!v[f]){
             printf("unsolvable\n");
         }
         else{
             for(int i = f ; i != f0 ; i=vv[i]){
                // cout << vv[<<endl;
              printf("%c",sss[i]);
                 //system("pause");
             }
             printf("\n");
         }
     }
     return ;
 }