Eight(经典题,八数码)

Eight

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

//就是类似九宫格那个游戏，不过这里9个格子大小都相等

//学了比较多的东西，才懂怎么做

这里我用的的是 A*+逆序数剪枝+hash判重 做的

A*其实也好理解，就是 bfs 升级版

这个博客写的很详细  http://www.cppblog.com/mythit/archive/2009/04/19/80492.aspx

因为，无论怎么移动，逆序数的奇偶性是不变的，所以用这个能剪枝

最大的问题就是怎么判重了，最多不过 9！种情况么，362880 ，每种情况对应一个数字，用一个 vis[ ]就能判重了,然后hash 判重就好理解了

还有许多方法，推荐一篇博客 http://www.cnblogs.com/goodness/archive/2010/05/04/1727141.html 有兴趣可以看看

A* + hash 判重 + 曼哈顿距离

 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <cstdlib>
 #include <algorithm>
 #include <iostream>
 #include <queue>
 #include <map>
 #include <vector>
 using namespace std;

 const int maxn=4e5+;// 400010 最多不超过这么多状态 362880
 const int hash_[]={,,,,,,,,};
 struct Node
 {
     int state[][];
     int x,y;
     int g,h;        //g代表已耗费,h代表估计耗费
     int hash_num;   //这个状态的 hash 值
     bool operator < (const Node PP) const
     {
         //return g+h > PP.g+PP.h;
         //1638ms
         return h==PP.h ? g>PP.g : h>PP.h;
         //686ms
     }
 }star,ans;

 int dx[]={,-,,};
 int dy[]={,,,-};
 char op_c[]={"durl"};
 struct Node2
 {
     int pre_hash;
     char op;
 }p[maxn];
 int vis[maxn];

 int count_hash(Node p)//获得hash值,计算的是 0-8 排列的hash
 {
     int i,j,k,hash_num=;
     for (i=;i<;i++)
     {
         k=;
         for (j=;j<i;j++)
         {
             if (p.state[j/][j%]>p.state[i/][i%])
                 k++;
         }
         hash_num+=k*hash_[i];
     }
     return hash_num;
 }

 int count_h(Node p)//注意位置，要细致
 {
     int i,all=;
     for (i=;i<;i++)
     {
         int e=p.state[i/][i%];
         if (e)
         {
             e-=;
             all+=abs(i/-e/)+abs(i%-e%);
         }
     }
     return all;
 }

 void print(int h)
 {
     if (p[h].pre_hash==-) return;
     print(p[h].pre_hash);
     printf("%c",p[h].op);
 }

 void A_star()
 {
     int i;

     star.hash_num = count_hash(star);
     star.g=;
     star.h=count_h(star);

     memset(vis,,sizeof(vis));
     vis[star.hash_num]=;
     p[star.hash_num].pre_hash=-; //头节点

     priority_queue <Node> Q;
     Q.push(star);

     Node e,n;
     int xx,yy;

     if (star.hash_num==ans.hash_num)//这个不能丢
     {
         printf("\n");
         return;
     }
     while (!Q.empty())
     {
         e=Q.top();
         Q.pop();

         for (i=;i<;i++)
         {
             xx=e.x+dx[i];
             yy=e.y+dy[i];
             if (xx<||yy<||xx>=||yy>=) continue;

             n=e;
             n.x=xx;
             n.y=yy;
             swap(n.state[xx][yy],n.state[e.x][e.y]);
             n.g++;
             n.h=count_h(n);
             n.hash_num=count_hash(n);

             if (vis[n.hash_num]) continue;

             p[n.hash_num].pre_hash=e.hash_num;  //记录这个状态的的父 hash
             p[n.hash_num].op=op_c[i];           //记录怎么由父hash移动来的

             vis[n.hash_num]=;
             if (n.hash_num==ans.hash_num)//说明到了
             {
                 print(n.hash_num);
                 printf("\n");
                 return;
             }
             Q.push(n);
         }
     }
 }

 int main()
 {
     char str[];
     int i;

     for(i=;i<;i++)                    //终点
         ans.state[i/][i%]=(i+)%;
     ans.hash_num=count_hash(ans);       //终点

     while(gets(str))
     {
         int i;
         int len=strlen(str);

         int j=;
         for(i=,j=;i<len;i++)
         {
             if(str[i]==' ')continue;
             if(str[i]=='x')
             {
                 star.state[j/][j%]=;
                 star.x=j/;
                 star.y=j%;
             }
             else star.state[j/][j%]=str[i]-'';
             j++;                         // j/3 记录行数
         }

         //判断逆序数
         int temp [],k=;
         for (i=;i<;i++)
             temp[i]=star.state[i/][i%];
         for (i=;i<;i++)
         {
             if (temp[i]==) continue;
             for (int j=;j<i;j++)
                 if (temp[j]>temp[i]) k++;
         }
         if (k%)
             printf("unsolvable\n");
         else
             A_star();
     }
     return ;
 }

 /*//错在这，浪费我2小时，才找出来！ == 竟然不报错，而且是全局变量，第一次也不会错！！！

         for (i=0,j=0;i<len;i++)
         {
             if (str[i]==' ')continue;
             else if (str[i]=='x')
             {
                 star.x=j/3;
                 star.y=j%3;
                 star.state[j/3][j%3]==0;
             }
             else star.state[j/3][j%3]=str[i]-'0';
             j++;
         }
 */

IDA* + 曼哈顿距离 这个空间就省下来了，改一下，十五数码也能做的，上一个就不行了，内存爆炸

 #include <stdio.h>
 #include <string.h>
 #include <math.h>
 #include <stdlib.h>

 #define size 3          //这里规定几数码

 int move[][]={{-,},{,-},{,},{,}};//上 左 右 下  置换顺序
 char op[]={'u','l','r','d'};

 int map[size][size],map2[size*size],limit,path[];
 int flag,length;

 // 十五数码 的表
 //int goal[16][2]= {{size-1,size-1},{0,0},{0,1},{0,2},
 //                  {0,3},{1,0},{1,1},{1,2},
 //                  {1,3},{2,0},{2,1},{2,2},
 //                  {2,3},{3,0},{3,1},{3,2}};//各个数字应在位置对照表

 // 八数码 的表
 int goal[][]= {{size-,size-},{,},{,},{,},
                                  {,},{,},{,},
                                  {,},{,}};      //各个数字应在位置对照表

 int nixu(int a[size*size])
 {
     int i,j,ni,w,x,y;  //w代表0的位置 下标，x y 代表0的数组坐标
     ni=;
     for(i=;i<size*size;i++)  //，size*size=16
     {
         if(a[i]==)  //找到0的位置
             continue;//w=i;

         for(j=i+;j<size*size;j++)  //注意！！每一个都跟其后所有的比一圈 查找小于i的个数相加
         {
             if (a[j]==)continue;
             if(a[i]>a[j])
                 ni++;
         }
     }
     //x=w/size;
     //y=w%size;
     //ni+=abs(x-(size-1))+abs(y-(size-1));  //最后加上0的偏移量
     if(ni%==)
         return ;
     else
         return ;
 }

 int hv(int a[][size])//估价函数，曼哈顿距离，小等于实际总步数
 {
     int i,j,cost=;
     for(i=;i<size;i++)
     {
         for(j=;j<size;j++)
         {
             int w=map[i][j];
             cost+=abs(i-goal[w][])+abs(j-goal[w][]);
         }
     }
     return cost;
 }

 void swap(int*a,int*b)
 {
     int tmp;
     tmp=*a;
     *a=*b;
     *b=tmp;
 }

 void dfs(int sx,int sy,int len,int pre_move)//sx,sy是空格的位置
 {
     int i,nx,ny;

     if(flag)
         return;

     int dv=hv(map);

     if (len==limit)
     {
         if(dv==)  //成功！ 退出
         {
             flag=;
             length=len;
             return;
         }
         else
             return;  //超过预设长度 回退
     }
     else if(len<limit)
     {
         if(dv==)  //短于预设长度 成功！退出
         {
             flag=;
             length=len;
             return;
         }
     }

     for(i=;i<;i++)
     {
         if(i+pre_move== && len>)//不和上一次移动方向相反，对第二步以后而言
             continue;
         nx=sx+move[i][];  //移动的四步 上左右下
         ny=sy+move[i][];

         if( <=nx && nx<size && <=ny && ny<size )  //判断移动合理
         {
             swap(&map[sx][sy],&map[nx][ny]);
             int p=hv(map);   //移动后的 曼哈顿距离p=16

             if(p+len<=limit&&!flag)  //p+len<=limit&&!flag剪枝判断语句
             {
                 path[len]=i;
                 dfs(nx,ny,len+,i);  //如当前步成功则 递归调用dfs
                 if(flag)
                     return;
             }
             swap(&map[sx][sy],&map[nx][ny]);  //不合理则回退一步
         }
     }
 }

 int main()
 {
     int pp;
     int i,j,k,sx,sy;
     char str[];

     while(gets(str))
     {
         int slen = strlen(str);
         j=;
         for(i=;i<slen;i++)
         {
             if (str[i]==' ')
                 continue;
             if (str[i]=='x')
                 map2[j]=;
             else
                 map2[j]=str[i]-'';
             j++;
         }

         for(i=;i<size*size;i++)  //给map 和map2赋值map是二维数组，map2是一维数组
         {
             if(map2[i]==)
             {
                 map[i/size][i%size]=;
                 sx=i/size;
                 sy=i%size;
             }
             else
             {
                 map[i/size][i%size]=map2[i];
             }
         }
         flag=,length=;
         memset(path,-,sizeof(path));  //已定义path[100]数组，将path填满-1
         if(nixu(map2)==)                     //该状态可达
         {
             limit=hv(map);  //全部的曼哈顿距离之和
             while(!flag&&length<=)//要求50步之内到达
             {
                 dfs(sx,sy,,);
                 if(!flag)
                 limit++; //得到的是最小步数
             }
             if(flag)
             {
                 for(i=;i<length;i++)
                 printf("%c",op[path[i]]);  //根据path输出URLD路径
                 printf("\n");
             }
         }
         else if(!nixu(map2)||!flag)
             printf("unsolvable\n");
     }
     return ;
 }