八数码 IDA* A *比较总结 HDU1043 POJ1077
这是一个经典的搜索题，做法很多可以详见此题的八境界做法，这里只阐述A*与IDA*算法。
A*算法:
简单来说是带估值函数的广搜。不同之处在于:对每个放入队列(open table)的节点计算估值函数h(x)，然后进行排序。这样出队时的顺序就不是自然顺序，而是有导向性的一个顺序，这样可以比直接搜索能更快的到达目标节点。
缺点：A*算法与bfs一样，都是搜索当前节点下，下一步的所有走法，所以需要耗费大量的空间来存储节点。
优点:同样的估值函数，a*找到的应该是较短路(至于是不是最短路，我觉得应该要看估值函数的选择)
//140ms
#include
#include
#include
#include
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
int fac[]={1,1,2,6,24,120,720,5040,40320};
int Cantor(int *s,int n){///康托展开
int i,j,num,temp;
num=0;
for(i=0;i=1
int i,j;
bool hash[10]={0};
for(i=0;i q;
int maxtol;
void bfs(){
mem(can,false);
while(!q.empty()) q.pop();
int tkey=Cantor(target,9);
can[tkey]=true;
ans[tkey][0]='\0';
q.push(node(tkey,2,2,0));
while(!q.empty()){
node tmp=q.front();q.pop();
CantorReverse(tmp.key+1,tt,9);
int x=tmp.x,y=tmp.y;
if(x>=1){
swap(tt[x*3+y],tt[(x-1)*3+y]);
tkey=Cantor(tt,9);
if(!can[tkey]){
q.push(node(tkey,x-1,y,tmp.tol+1));
can[tkey]=true;
for(int i=0;i=1){
swap(tt[x*3+y],tt[x*3+y-1]);
tkey=Cantor(tt,9);
if(!can[tkey]) {
q.push(node(tkey,x,y-1,tmp.tol+1));
can[tkey]=true;
for(int i=0;i=0;--i)
printf("%c",ans[tkey][i]);
printf("\n");
}
char op[3];
int main(){
bfs();
while(scanf("%s",op)!=EOF){
int i;
for(i=0;i<=7;++i){
if(op[0]=='x') d[i]=0;
else d[i]=op[0]-'0';
scanf("%s",op);
}
if(op[0]=='x') d[i]=0;
else d[i]=op[0]-'0';
solve();
}
return 0;
}
IDA*
IDA*j简单说来就是带估值函数的迭代加深算法。估值函数可以和A*一样。原理大概是先从起点开始用估值函数估计到终点的深度，以此作为迭代加深搜索的初始阈值。往后每次记录经过的每个点到终点的估计值，并取最小值。如果没找到解则说明阈值太小，需要加大，则把最小深度加上，直到搜到目标。
优点:由于不需要记录当前状态的所有下一个状态，空间消耗较小。
缺点:由于深度可能不够，便可能需要多次迭代，所以可能会重复走。找到解，但有可能不是最短路解。
#include
#include
#include
#define inf 0x3f3f3f3f
using namespace std;
char s[1005];
int da[10],start,depth,mi;
int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
char op[]={'r','d','l','u'};
bool flg;
// int geth(){
// int dif=0;
// for(int i=0;i<9;i++){
// if(da[i]/3!=i/3||da[i]%3!=i%3) dif++;
// }
// return dif;
// }
//这里试用了两个估值函数。第一个是用不在位置上的个数来作为估值函数。第二个是用欧几里得距离来作为估值函数。结果说明欧几里得距离会更优
int geth(){
int tot=0;
for(int i=0;i<9;i++){
if(da[i]!=8) tot+=abs(i/3-da[i]/3)+abs(i%3-da[i]%3);
}
return tot;
}
void dfs(int start,int d,int pre){
int h=geth();
mi=min(h,mi);
if(d+h>depth||flg) return ;
if(!h){
s[d]='\0';
flg=true;
return;
}
for(int i=0;i<4;i++){
int tx=start/3+dy[i];
int ty=start%3+dx[i];
int txx=tx*3+ty;
if(tx>2||tx<0||ty>2||ty<0||txx==pre) continue;
swap(da[txx],da[start]);
s[d]=op[i];
dfs(txx,d+1,start);
if(flg) return;
swap(da[txx],da[start]);
}
}
//奇偶剪枝
bool check(){
int tot=0;
for(int i=0;i<9;i++)
for(int j=i+1;j<9;j++){
if(da[i]>da[j]&&da[j]!=8&&da[i]!=8) tot++;
}
return tot&1? false:true;
}
int main(){
while(scanf("%s",s)!=EOF){
if(s[0]=='x') da[0]=8,start=0;
else da[0]=s[0]-'0'-1;
for(int i=1;i<9;i++){
scanf("%s",s);
if(s[0]=='x') da[i]=8,start=i;
else da[i]=s[0]-'0'-1;
}
if(!check()){
printf("unsolvable\n");
continue;
}
/*idaSTar*/
flg=false;
depth=geth();
while(!flg){
mi=inf;
dfs(start,0,-1);
depth+=mi;
// cout<<"dep:"< 附带一个逆序数奇偶剪枝的证明:https://blog.csdn.net/u011008379/article/details/40144147