八数码（POJ-1077或HDU-1043）
Eight
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:
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:
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.
InputYou 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 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.
1 2 3
x 4 6
7 5 8
is described by this list:
1 2 3 x 4 6 7 5 8
OutputYou 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 8Sample Output
ullddrurdllurdruldr
神奇的八数码，崩溃了老长时间，要着好这道题真不容易，先要学好以下的推荐知识。
最重要的是A*算法，f = g + h,其中g为已花费的代价，h为剩余代价，A*算法的详细介绍可以参考这篇博客A*算法，
这里我们只用到了其中的皮毛，里面还有好多学问值得我们学习。
<1> : 康托展开，在这里推荐一篇极好的博客：康托展开。
<2> : 曼哈顿距离，这个很好理解，在平面直角坐标系中设点（x1,y1),(x2,y2),那么这两个点之间的
曼哈顿距离=abs(x1-x2) + abs(y1-y2)。
<3> : 哈希问题，这里我们用康托展开来判重。
<4> : 判断是否有解，根据逆序数直接判断有无解，对于一个八数码，依次排列之后，每次是将空位和相邻位进行调换，研究后会发现，每次调换，逆序数增幅都为偶数，也就是不改变奇偶性，因为最终状态12345678的逆序数为零，所以只有初始状态的逆序数为偶数才有解。
至于优先队列的排序规则，这里采用的是先h后g，当然还有很多种选择，只不过这种的更省时，当然我们也可以实验一下其他的。
这里附上八数码八境界，可以提高一下我们自己，本人的代码只在第六境界中徘徊，还是菜啊。
这里提醒一下，标准的结果不止一种，为此我还郁闷了很长时间。具体原因可能是因为bfs的时候上下左右走的顺序不一样。
#include
#include
#include
#include
#include
#include
#include
using namespace std;
struct node{
int op[9];
int x;
int g,h;
int hash;
bool operator <(node c)const
{
if(c.h==h)
return g>c.g;
else
return h>c.h;
}
};
int hash_op[9] = {1,1,2,6,24,120,720,5040,40320};//存储的阶乘，可以直接使用，省时。
int nex_t[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
char nexx[5] = "rldu";
char lu[700000];
int pre[700000];
int vis[700000];
int get_hash(int a[9])
{
int sum = 0;
for(int i=0;i<9;i++)
{
int k = 0;
for(int j=i;j<9;j++)
if(a[i]>a[j])k++;
sum += k*hash_op[9-i-1];
}
return sum;
}
int get_h(int a[9])
{
int ans = 0;
for(int i=0;i<9;i++)
{
int xx = (a[i]-1)/3; //为什么要减掉1，因为这里xx保存的是a[i]最终应该在第几行,位于（0，0）位置的数是1而不是0
int yy = (a[i]-1)%3; // 同上
if(a[i]==0)xx = 2,yy = 2;//最终状态0位于第2行，第2列
ans += abs(xx-i/3) + abs(yy - i%3);// i/3 存储的是a[i]现在在第几行，i%3存储的是a[i]现在在第几列。这里不要搞混了，想要更明白的话专辑举个例子试验一下，俺智商低，就是这么办的。
}
return ans;
}
bool isok(int a[9])
{
int sum = 0;
for(int i=0;i<9;i++)
{
for(int j=i;j<9;j++)
{
if(a[i]>a[j]&&a[i]&&a[j]) sum++;//求逆序数的时候不要加上了0，这里不要大意。
}
}
if(sum%2==0)return true;
return false;
}
priority_queue pp;
node cur,now;
int main()
{
char q[50];
int pos;
int en[9]={1,2,3,4,5,6,7,8,0};
int cur_op[9];
while(gets(q)!=NULL)
{
memset(vis,0,sizeof(vis));
memset(pre,0,sizeof(pre));
memset(lu,'\0',sizeof(lu));
while(!pp.empty())pp.pop();//一定不要忘了清空队列
int k= 0;
for(int i=0;i=0&&xx<3&&yy>=0&&yy<3))continue;
memcpy(&now.op,&cur.op,sizeof(cur.op));
swap(now.op[cur.x],now.op[xx*3+yy]);
int p = get_hash(now.op);
if(vis[p]!=0)continue;
now.hash = p;vis[p]=1;now.x = xx*3+yy;now.g = cur.g + 1;
now.h = get_h(now.op);
pre[p] = cur.hash;
lu[p] = nexx[i];
pp.push(now);
}
}
pos = cur.hash;
//printf("%d\n",pos);
char c[700000];
memset(c,'\0',sizeof(c));
int k=0;
while(pre[pos]!=0)
{
c[k] = lu[pos];
pos = pre[pos];
k++;
}
for(int i=k-1;i>=0;i--)printf("%c",c[i]);
printf("\n");
}
}
return 0;
}