# HDU1043 Eight[bfs]

A - Eight
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

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<vector>
using namespace std;
const int N=4e5;
int dir[4][2]={{-1,0},{0,1},{1,0},{0,-1}};
int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
const int aim=46233;
bool mark[N];
string ans[N];
char dis[]="dlur";//注意反过来...   从12345678x开始的  所以向下是向上 向左是向右
struct node
{
int num[10];
int x,ha;
string path;
};
int Cantor(int num[])// 用康拓展开计算hash值
{
int sum=0;
for (int i=0 ; i<9 ; i++)
{
int cnt=0;
for (int j=i+1; j<9 ; j++)
if (num[i]>num[j])
cnt++;
sum+=cnt*fac[9-i-1];
}
return sum;
}
queue<node>q;
void bfs(node start)
{
while (!q.empty())
q.pop();
node later;
q.push(start);
while (!q.empty())
{
start=q.front();
q.pop();
int x=start.x/3;
int y=start.x%3;
for (int i=0 ; i<4 ; i++)
{
int nx=x+dir[i][0];
int ny=y+dir[i][1];
if (nx<0 || nx>=3 || ny<0 || ny>=3)
continue;
later=start;
later.x=nx*3+ny;
later.num[start.x]=later.num[later.x];
later.num[later.x]=0;
later.ha=Cantor(later.num);
if (!mark[later.ha])
{
mark[later.ha]=1;
later.path=dis[i]+later.path;
ans[later.ha]=later.path;
q.push(later);
}
}
}
}
int main()
{
//printf("%d\n",Cantor(num)); //答案的哈希值 1,2,3,4,5,6,7,8,0
char ch;
memset(mark,0,sizeof(mark));
node now;
for (int i=0 ; i<8 ; i++)
now.num[i]=i+1;
now.num[8]=0;
now.x=8;
now.path="";
ans[aim]=now.path;
mark[aim]=1;
bfs(now);
while (cin>>ch)//scanf一直输入会出现错误...
{
if (ch=='x')
now.num[0]=0;
else
now.num[0]=ch-'0';
for (int i=1 ; i<9 ; i++)
{
cin>>ch;
if (ch=='x')
now.num[i]=0;
else
now.num[i]=ch-'0';
}
now.ha=Cantor(now.num);
if (mark[now.ha])
cout<<ans[now.ha]<<endl;
else
printf("unsolvable\n");
}
return 0;
}