HDU-1043 Eight八数码 搜索问题（bfs+hash 打表 IDA* 等）

题目链接 https://vjudge.net/problem/HDU-1043

经典的八数码问题，学过算法的老哥都会拿它练搜索

题意：

给出每行一组的数据，每组数据代表3*3的八数码表，要求程序复原为初始状态

思路：

参加网站比赛时拿到此题目，因为之前写过八数码问题，心中暗喜，于是写出一套暴力bfs+hash，结果TLE呵呵

思路一：bfs+hash(TLE)

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <set>
 using namespace std;
 const int StMax=, HashMax=;
 struct State{
     char map[][];
     int dis, fx, x, y, id, fa;
 }start, st[StMax];
 int head[HashMax], mynext[StMax], dir[][]={{,},{-,},{,},{,-}};
 char ch[]={'r', 'l', 'd', 'u'};
 int myhash(State &a){
     a.id=;
     for (int y=; y<; y++)
         for (int x=; x<; x++)
             a.id=a.id*+((a.map[y][x]=='x')?'':a.map[y][x])-'';
     return a.id%HashMax;
 }
 int insert(int rear){
     int h=myhash(st[rear]), u=head[h];
     while(u){
         if (st[rear].id==st[u].id) return ;
         u=mynext[u];
     }
     mynext[rear]=head[h]; head[h]=rear;
     return ;
 }
 void output(int u){
     if (u==) printf("unsolvable");
     else if (u==) return;
     else{
         output(st[u].fa);
         printf("%c", ch[st[u].fx]);
     }
 }

 int bfs(void){
     st[]=start; insert();
     if (start.id==) return ;
     int front=, rear=;//2,1 for hash
     while (front<rear){
         State &s=st[front];
         for (int i=; i<; i++){
             int nx=s.x+dir[i][], ny=s.y+dir[i][];

             if (nx< || nx>= || ny< || ny>=) continue;
             State &t=st[rear]; memcpy(&t, &s, sizeof(s));
             t.map[s.y][s.x]=s.map[ny][nx];
             t.map[ny][nx]='x';
             if (!insert(rear)) continue;
             t.x=nx; t.y=ny; t.fx=i; t.dis++; t.fa=front;

             if (t.id==) return rear;
             rear++;
         }front++;
     }
     return ;
 }
 int input(void){
     char a[]; int p=, re;
     if ((re=scanf("%[^\n]\n", a))!=) return ;
     for (int y=; y<; y++)
         for (int x=; x<; x++){
             while(a[p]==' ') p++;
             if ((start.map[y][x]=a[p])=='x') {start.x=x; start.y=y;}
             p++;
         }
     start.dis=;
     return ;
 }

 int main(void){
     while (input()){
         memset(head, , sizeof(head));
         memset(mynext, , sizeof(mynext));
         output(bfs()); printf("\n");
     }

     return ;
 }

看来hdu的数据比较强，比较多，考虑到八数码问题状态数不是非常大(<9!=362880<10^6)

(注：参考紫书 一般情况状态总数小于10^6在可接受范围)
于是考虑bfs的预处理打表，在此期间了解到康托展开用以编码全排列

思路二：bfs打表+cantor(AC)

中间三个数据分别是Time(ms) Mem(MB) Length

 #include <cstdio>
 #include <cstring>
 #include <vector>
 using namespace std;
 typedef int State[];
 const int STMAX=;
 int fact[]={,,,,,,,,,}, dir[][]={,-,-,,,,,};
 int st[STMAX][], vis[STMAX], myprev[STMAX], fx[STMAX], goal=, stcode[STMAX];
 char toch[]={'d','r','u','l'};//反方向
 int encode(int map[], int n){
     int code=;
     for (int i=; i<n; i++){
         int cnt=;
         for (int j=i+; j<n; j++)
             if (map[i]>map[j]) cnt++;
         code+=cnt*fact[n--i];
     }return code;
 }

 int input(void){
     char ch;
     for (int i=; i<; i++){
         do{if (scanf("%c", &ch)!=) return ;}while(ch==' '||ch=='\n');
         if (ch=='x'||ch=='X') ch='';
         st[][i]=ch-'';
     }
     return ;
 }

 int check(void){
     int sum=;
     for (int i=; i<; i++){
         if (st[][i]==) continue;
         for (int j=i+; j<; j++){
             if (st[][j]==) continue;
             if (st[][i]>st[][j]) sum++;
         }
     }
     return sum;
 }

 void show(vector<char> &path, int code){
     if (code==goal) return;
     else{
         show(path, myprev[code]);
         path.push_back(toch[fx[code]]);
     }
 }

 void pre(void){
     memset(vis, , sizeof(vis));
     memset(myprev, , sizeof(myprev));
     State s={,,,,,,,,}; memcpy(st[], &s, sizeof(s));
     vis[stcode[]=encode(st[], )]=;
     int front=, rear=;
     while (front<rear){
         State &a=st[front];

         int z=; while (a[z]) z++;
         for (int i=; i<; i++){
             int nx=z%+dir[i][], ny=z/+dir[i][];
             if (nx< || nx> || ny< || ny>) continue;
             State &b=st[rear]; memcpy(&b, &a, sizeof(a));
             b[nx+ny*]=; b[z]=a[nx+ny*];

             int code=encode(b, );
             if (vis[code]) continue;
             fx[code]=i; myprev[code]=stcode[front];
             stcode[rear]=code; vis[code]=; rear++;
         }front++;
     }
 }

 int main(void){
     pre();
     while (input()){
         vector<char> path;
         int code=encode(st[], );
         if (!vis[code]) printf("unsolvable\n");
         else {
             show(path, code);
             for (int i=path.size()-; i>=; i--)
                 printf("%c", path[i]);
             printf("\n");
         }
     }

     return ;
 }

解题到此结束，但在此期间想到过新学的IDA*，按结果来说也是不错的

思路三：IDA*(AC)

(没错，我特地重新上传了一次，因为之前的代码有不少啰嗦的地方)

我觉得此题用作IDA*的入门题目非常合适，dfs()中排除上次操作的反方向(prevDir)是一个很实用的小技巧，排除了许多分支

 #include <cstdio>
 #include <cmath>
 #include <cstring>
 #include <vector>
 using namespace std;
 typedef int State[];
 State st, goal={,,,,,,,,};
 int maxd;
 int isdir[]={,,,}, orix[]={,,,,,,,,}, oriy[]={,,,,,,,,}, dir[][]={,-,-,,,,,};
 char toch[]={'u', 'l', 'd', 'r'};
 int input(void){
     char ch;
     for (int i=; i<; i++){
         do{if(scanf("%c", &ch)!=) return ;}while (ch==' '||ch=='\n');
         if (ch=='x') ch='';
         st[i]=ch-'';
     }
     return ;
 }

 int check(void){
     int sum=;
     for (int i=; i<; i++){
         if (st[i]==) continue;
         for (int j=i+; j<; j++){
             if (st[j]==) continue;
             if (st[i]>st[j]) sum++;
         }
     }
     return sum;
 }
 inline int calc(State &a){
     int sum=;
     for (int i=; i<; i++)
         sum+=abs(i%-orix[st[i]])+abs(i/-oriy[st[i]]);
     return sum;
 }

 int dfs(State &a, vector<char> &path, int z, int prevdir, int d){
     int h=calc(a);
     if (h==) return ;
     if (maxd==d) return ;

     if (h>*(maxd-d)) return ;
     for (int i=; i<; i++){
         if (prevdir!=- && isdir[prevdir]==i) continue;//great effect
         int nx=z%+dir[i][], ny=z/+dir[i][];
         if (nx< || nx> || ny< || ny>) continue;
         a[z]=a[nx+ny*]; a[nx+ny*]=; path.push_back(toch[i]);
         if (dfs(a, path, nx+ny*, i, d+)) return ;
         a[nx+ny*]=a[z]; a[z]=; path.pop_back();
     }return ;
 }

 int main(void){
     while (input()){
         if (check()%) {printf("unsolvable\n"); continue;}
         int z=; while(st[z]) z++;
         for (maxd=; ; maxd++){
             vector<char> path;
             if (dfs(st, path, z, -, )){
                 for (int i=; i<path.size(); i++) printf("%c", path[i]);
                 printf("\n");
                 break;
             }
         }
     }
     return ;
 }

其他思路：

双向BFS：

若需要路径，则一定需判断节点是否由另一队列走过，并链接两队列中的路径（考虑cantor）
A*+cantor：

使用priority_queue（优先队列），启发函数类似IDA*

（实际情况下我比较喜欢IDA*，因为它比较短，也好找错。。。）