POJ1077、HDU1043 Eight 八数码问题：双向BFS、A*
Problem Address：http://poj.org/problem?id=1077
Problem Address：http://acm.hdu.edu.cn/showproblem.php?pid=1043
【前言】
第一次写八数码问题。
这份代码写得也是够残的。
还好效率不是很低。
HDU的数据明显比POJ的强。而且HDU里有初末状态相同的情况，而POJ没有。
这也是后来改成双向A*之后在HDU上狂WA的原因。
提交了20多次之后才发现真相= =
【思路】
典型的八数码问题。
九宫格中有1-8的数字，空出一位用于数字的移动。求从一个状态转移到另一个状态的路径。
具体的存储方式可以到网上搜一下。
以下简单介绍几种应用于八数码问题的搜索算法。
DFS：
由于不知道步数，所以用DFS是不可取的。
BFS：
从初始状态开始，每一步向四个方向扩展。直到达到末状态。
简单的BFS使用的空间很大，时间也很大，当步数增加时节点数膨胀很快。
因为，就八数码问题，一般的BFS不太可取。
双向BFS：
从初状态和末状态同时开始扩展。扩展方式与一般BFS相同。
直到两者有交点时停止查找。
相比于一般的BFS，双向BFS无论是在空间还是时间方面，都有很大的提升。
A*启发式搜索：
利用启发式函数 f'() = a*g'() + b*h'()，g'()表示当前以使用代价（可用步数表示），h'()表示达到目标还需花费的代价（可用manhattan距离或者相同位置不同数字的个数表示）。
启发式搜索相对于前面的搜索提升是巨大的。访问的结点很少，空间和时间的使用也因此很少。
可以这样看，BFS都是A*的一种特殊形式。
当b=0且a!=0时，f'() = a*g'()，即只于结点所耗步数有关，即为一般的BFS。
所以，通过改变a和b的值可以在一定程度上提升搜索效率。
双向A*：
A*与双向BFS的结合。
【代码】
这份代码是双向A*，但是通过改变里面的参数可以实现BFS、双向BFS、A*等。
#include <iostream>
#include <queue>
using namespace std;
const int maxhash = 400000;
int start, end = 123456789;
int le[9] = {1,10,100,1000,10000,100000,1000000,10000000,100000000};
int te[9] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320};
int manhattan[9][9] = {
{0,1,2,1,2,3,2,3,4},
{1,0,1,2,1,2,3,2,3},
{2,1,0,3,2,1,4,3,2},
{1,2,3,0,1,2,1,2,3},
{2,1,2,1,0,1,2,1,2},
{3,2,1,2,1,0,3,2,1},
{2,3,4,1,2,3,0,1,2},
{3,2,3,2,1,2,1,0,1},
{4,3,2,3,2,1,2,1,0}};
int re[9];
struct HASH
{
bool visited;
int value;
int pre;
char op;
bool inqueue;
int g;
int h;
bool opposite;
}hash[maxhash];
struct cmp
{
bool operator()(const int &a, const int &b)
{
int fa = hash[a].g + 10*hash[a].h;
int fb = hash[b].g + 10*hash[b].h;
return fa>fb;
}
};
char get_opposite(char op)
{
switch(op)
{
case 'u':
return 'd';
case 'd':
return 'u';
case 'l':
return 'r';
case 'r':
return 'l';
default:
return 'x';
}
}
priority_queue<int, vector<int>, cmp> q;
void init_hash()
{
int i;
for (i=0; i<maxhash; i++)
{
hash[i].g = hash[i].h = 0;
hash[i].inqueue = false;
hash[i].visited = false;
hash[i].pre = -1;
}
}
void init_rank(int x)
{
int i;
int t = x%10;
x /= 10;
for (i=7; i>=0; i--)
{
if (i+1<t) re[x%10-1] = i;
else re[x%10-1] = i+1;
x /= 10;
}
re[8] = t-1;
}
bool check_even(int x)
{
int temp[8];
int i, j;
x /= 10;
for (i=7; i>=0; i--)
{
temp[i] = x%10;
x /= 10;
}
int sum = 0;
for (i=1; i<8; i++)
{
for (j=0; j<i; j++)
{
if (temp[i]<temp[j])
sum++;
}
}
if (sum&1==1) return false;
else return true;
}
int get_manhattan(int x, bool opposite)
{
int i;
int h = 0;
int t = x%10;
x /= 10;
if (opposite==false)
{
for (i=7; i>=0; i--)
{
if (i+1<t) h += manhattan[x%10-1][i];
else h += manhattan[x%10-1][i+1];
x /= 10;
}
}
else
{
for (i=7; i>=0; i--)
{
if (i+1<t) h += manhattan[i][re[x%10-1]];
else h += manhattan[i+1][re[x%10-1]];
x /= 10;
}
}
return h;
}
int move(char op, int x)
{
int t0, t1, t2;
switch(op)
{
case 'u':
t0 = 9 - x%10 + 1;
t1 = x/le[t0];
t2 = t1%1000;
t1 = t1-t2 + (t2%100)*10 + t2/100;
t1 *= le[t0];
return (t1+(x%le[t0])-3);
case 'r':
return x+1;
case 'd':
t0 = 9 - x%10 - 2;
t1 = x/le[t0];
t2 = t1%1000;
t1 = t1-t2 + (t2%10)*100 + t2/10;
t1 *= le[t0];
return (t1+(x%le[t0])+3);
case 'l':
return x-1;
default:
return x;
}
}
int get_hash(int x)
{
int i, j, k;
int sum = (9-x%10)*te[8];
x /= 10;
int temp[8];
for (i=7; i>=0; i--)
{
temp[i] = x%10;
x /= 10;
}
for (i=1; i<8; i++)
{
k = 0;
for (j=0; j<i; j++)
{
if (temp[i]<temp[j])
k++;
}
sum += k*te[i];
}
return sum;
}
void show(int x)
{
if (hash[x].pre==-1)
return;
show(hash[x].pre);
printf("%c", hash[x].op);
}
void show_opposite(int x)
{
if (hash[x].pre!=-1)
{
printf("%c", get_opposite(hash[x].op));
show_opposite(hash[x].pre);
}
}
bool valid(int x, char op, int pre)
{
int hx = get_hash(x);
if (pre==-1 && !hash[hx].visited)
{
if (x==end) hash[hx].opposite = true;
else hash[hx].opposite = false;
hash[hx].value = x;
hash[hx].h = get_manhattan(x, hash[hx].opposite);
hash[hx].inqueue = true;
hash[hx].visited = true;
hash[hx].op = op;
hash[hx].g = 0;
hash[hx].pre = -1;
q.push(hx);
return true;
}
if (!hash[hx].visited)
{
hash[hx].g = hash[pre].g + 1;
hash[hx].op = op;
hash[hx].pre = pre;
hash[hx].visited = true;
hash[hx].inqueue = true;
hash[hx].opposite = hash[pre].opposite;
hash[hx].h = get_manhattan(x, hash[hx].opposite);
hash[hx].value = x;
q.push(hx);
}
else
{
if (hash[hx].opposite ^ hash[pre].opposite)
{
if (hash[hx].opposite)
{
show(pre);
printf("%c", op);
show_opposite(hx);
}
else
{
show(hx);
printf("%c", get_opposite(op));
show_opposite(pre);
}
printf("\n");
return true;
}
else if (hash[hx].inqueue && hash[hx].g>hash[pre].g+1)
{
hash[hx].g = hash[pre].g + 1;
hash[hx].op = op;
hash[hx].pre = pre;
if (!hash[hx].inqueue)
{
hash[hx].inqueue = true;
q.push(hx);
}
}
}
return false;
}
bool expand(int t)
{
int j;
int temp = t%10;
int ht = get_hash(t);
hash[ht].inqueue = false;
if (temp>3)
{
j = move('u', t);
if (valid(j, 'u', ht)) return true;
}
if (temp%3!=0)
{
j = move('r', t);
if (valid(j, 'r', ht)) return true;
}
if (temp<7)
{
j = move('d', t);
if (valid(j, 'd', ht)) return true;
}
if (temp%3!=1)
{
j = move('l', t);
if (valid(j, 'l', ht)) return true;
}
return false;
}
int main()
{
char str[100];
int i, j;
int t;
while(cin.getline(str, 100))
{
start = 0;
for (i=0,j=0; str[i]!='\0'; i++)
{
if (str[i]!=' ')
{
if (str[i]=='x')
{
t = j + 1;
}
else
{
start = start*10 + (str[i]-'0');
j++;
}
}
}
start = start*10 + t;
if (!check_even(start))
{
printf("unsolvable\n");
continue;
}
if (start==end)
{
printf("\n");
continue;
}
init_hash();
init_rank(start);
while(!q.empty()) q.pop();
valid(start, 'x', -1);
valid(end, 'x', -1);
while(!q.empty())
{
int ht = q.top();
t = hash[ht].value;
q.pop();
if (expand(t)) break;
}
}
return 0;
}