题目链接：
hdu 1043：http://acm.hdu.edu.cn/showproblem.php?pid=1043
poj 1077： http://poj.org/problem?id=1077
题意：自己念第一次看到这个题，让我想到了小时候玩的华容道？或者是win7小程序里的那只巨嘴鸟？嗯嗯 大意就是给你个3*3的网格，在里面添上0~8 每次操作就是将0上下左右的数字和0交换，问你能不能变成123456780的状态，如果能，输出最小步数。
题意很简单，思路也好想，广搜跑一下就好了。主要想的问题就是，怎么将状态存起来。相信经过之前的题目，大家应该有了一点想法，因为只有九位，完全可以应一个int就将一个状态存起来。但是这样还不是最有优秀的哈希方式，最优秀的方法自然是将9！个状态对应0~9!-1有没有这样的方法呢？当然有！
康托展开完美的解决了这个问题。康托展开解决的问题很简单，就是建立某个排列和它所在位置的关系。
详情请参考这篇博客：https://blog.csdn.net/fengyuzhicheng/article/details/79371008 这篇博客讲康托展开讲的非常好 没错，就是我
有了这个理论的支撑，这个题的状态转移就好写了。只需要每次计算康托展开和逆变换，就可以很方便的进行搜索了。
还有一个彩蛋，关于可行判断的。在讲线性代数的时候，我们学习到了一个很神奇的东西叫做逆序数（北大课件上的逆序数定义好像是不对的，查了很多关于逆序数的定义，都是计算在比当前数大的个数，不过对于这道题，无伤大雅，在这道题中，无论采用那种方法，即使计算的数可能不同，但奇偶排列的状况是一样的，而且从原理上讲，两种方式都可以）当逆序数是奇数时是奇排列，偶数就是偶排列，然后就是，在本题中，上下左右四种方法都不会改变排列的奇偶性（这个可以自己推一下）这样，在一开始就可以判断是否需要搜，也算是一种可行性剪枝吧。
另外，这道题，我是写的双向广搜，单向广搜可能要超时
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <queue>
using namespace std;
char s[1000];
string ANS[2];
int f[10];
int a[10];
char z[2][10] = {"lrud","rldu"};
int dir[4] = {1,-1,3,-3};
int p_dir[4][9] = {
1,1,0,1,1,0,1,1,0,
0,1,1,0,1,1,0,1,1,
1,1,1,1,1,1,0,0,0,
0,0,0,1,1,1,1,1,1
};
struct Node {
int zero, status;
int s[9];
Node(){};
Node(int Z,int S){
zero = Z, status = S;
}
};
struct Path {
int fa; char c;
Path(){};
Path(int FA,int C) {
fa = FA, c = C;
}
};
Path path[400000];
queue<Node> q[2];
int jud[400000];
int Cantor(int a[]) {
int ans = 0;
for (int i = 0; i < 9; i++) {
int t = 0;
for (int j = 0; j < i; j++)
if (a[i]>a[j]) t++;
ans+=f[9-i-1]*(a[i]-1-t);
}
return ans;
}
int ca;
void dbfs(){
while (!q[0].empty()&&!q[1].empty()) {
for (int j = 0; j < 2; j++) {
for (int i = 0; i < 4; i++) {
if (p_dir[i][q[j].front().zero]) {
Node t = q[j].front();
swap(t.s[t.zero],t.s[t.zero+dir[i]]);
t.status = Cantor(t.s);
if (!jud[t.status]) {
path[t.status].fa = q[j].front().status;
path[t.status].c = z[j][i];
jud[t.status] = j+1;
t.zero += dir[i];
q[j].push(t);
}
else{
if (jud[t.status]==2-j) {
int t1 = q[j].front().status;
int t2 = t.status;
ANS[j]+=z[j][i];
while (path[t1].fa!=-1) {
ANS[j]+=path[t1].c;
t1 = path[t1].fa;
}
while (path[t2].fa!=-1) {
ANS[1-j]+=path[t2].c;
t2 = path[t2].fa;
}
reverse(ANS[1].begin(),ANS[1].end());
cout << ANS[1]<<ANS[0]<<endl;
return;
}
}
}
}
q[j].pop();
}
}
puts("unsolvable");
}
int check(int a[]) {
int ans = 0;
for (int i = 0; i < 9; i++) {
for (int j = 0; j < i; j++) {
if(a[i]<a[j]&&a[j]!=9) ans++;
}
}
return ans;
}
int main() {
f[0] = 1;
for (int i = 1; i < 10; i++) f[i] = f[i-1]*i;
while(cin.getline(s, 1000)) {
memset(path,0,sizeof(path));
memset(jud,0,sizeof(jud));
q[0] = q[1] = queue<Node>();
ANS[0].clear();ANS[1].clear();
int j = 0, t = 0;
for (int i = 0; i < strlen(s); ++i) {
if (s[i]<='8'&&s[i]>='1') {
a[j++] = s[i]-'0';
}
else if (s[i]=='x'){
a[j++] = 9;
t = j-1;
}
}
if(check(a)%2) {
puts("unsolvable");
continue;
}
int ans = Cantor(a);
q[1].push(Node(t,ans));
q[0].push(Node(8,0));
for (int i = 0 ; i < 9; i++) {
q[0].front().s[i] = i+1;
q[1].front().s[i] = a[i];
}
path[0].fa = path[ans].fa= -1;
jud[0] = 1;
jud[ans] = 2;
dbfs();
}
return 0;
}