# Eight HDU 1043 AND POJ 1077

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

康拓展开式

//判断这个数在其各个数字全排列中从小到大排第几位
// X = an*(n-1)! + an-1*(n-2)! + ... + a2*1! + a1*0!;

int cator(int t[])                            //康拓展开式
{
int sum = 0;
for(int i = 0; i < 9; i++)
{
int num = 0;
for(int j = i+1; j < 9; j++)
if(t[i] > t[j])
num++;
sum += num*fac[8-i];  //((n-1)-i)
}
return sum;
}

逆运算

int n;            //表示有几位数
int book[110];
int fac[] = {1,1,2,6,24,120,720,5040,40320,362880};   //第 i！的数值

// k = an*(n-1)! + an-1*(n-2) + ... + a2*1! + a1*0!;

void reverse_cator(int k,char s[])
{
memset(book,0,sizeof(0));
int j;
for(int i = 0;i < n; i++)
{
int t = k/fac[n-i-1];      //表示的是 an;
for(j = 1; j <= n; j++)
if(!vis[j])
{
if(t == 0)
break;
--t;
}

s[i] = j+'0';
vis[j] = 1;
k = k%fac[n-1-i];        //继续往下找
}
}

//逆向搜索,从终点往前搜索
#include<stdio.h>
#include<queue>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;

int a[]={-1,1,0,0};
int b[]={0,0,-1,1};

char str[]={"durl"};     //由于从终点往前找，故方向相反

int fac[]={1,1,2,6,24,120,720,5040,40320,362880};

int book[370000];

struct note			//存储路径
{
char st;			//存储方向

}f[370000];

struct node
{
int x0;
int num;			//s[]在全排列中从大到小第几位
int s[10];		    // 存储数康拓展开式	所求的数值
};

//判断这个数在其各个数字全排列中从小到大排第几位
// X = an*(n-1)! + an-1*(n-2)! + ... + a2*1! + a1*0!;

int cator(int t[])                            //康拓展开式
{
int sum = 0;
for(int i = 0; i < 9; i++)
{
int num = 0;
for(int j = i+1; j < 9; j++)
if(t[i] > t[j])
num++;
sum += num*fac[8-i];  //((n-1)-i)
}
return sum;
}

void bfs()
{
memset(book,0,sizeof(book));
queue<node>Q;
node now,tmp;
for(int i = 0; i < 8; i++)
now.s[i] = i+1;
now.s[8] = 0;
now.x0 = 8;
now.num = 0;
Q.push(now);
while(!Q.empty())
{
now = Q.front();
Q.pop();
int x = now.x0/3;
int y = now.x0%3;
for(int i = 0;i < 4; i++)
{
int tx = x + a[i];
int ty = y + b[i];
if(tx < 0 || ty < 0 || tx > 2 || ty > 2 )
continue;
tmp = now;
tmp.x0 = tx*3 + ty;
swap(tmp.s[tmp.x0],tmp.s[now.x0]);
tmp.num = cator(tmp.s);
if(!book[tmp.num])
{
book[tmp.num] = 1;
f[tmp.num].st =  str[i];
Q.push(tmp);
}
}
}
return ;
}

int main()
{
char c;
int t[10];
bfs();
while(cin >> c)            //cin不吸收空格回车等字符
{
if(c == 'x')
t[0] = 0;
else
t[0] = c-'0';
for(int i = 1; i < 9; i++)
{
cin >> c;
if(c == 'x')
t[i] = 0;
else
t[i] = c-'0';
}
int n = cator(t);
//printf("%d\n",n);
if(book[n])
{
while(n)
{
printf("%c",f[n].st);
}
printf("\n");
}
else
printf("unsolvable\n");
}
return 0;
}


1  我们是从后往前找的，所有方向应该正好相反（上下左右的坐标，  保存的字符应该是下上右左）

2  数据有多重答案，所有不要一直纠结自已的运行结果和测试数据不一样啊。