八数码 IDA* A *比较总结 HDU1043 POJ1077

   这是一个经典的搜索题，做法很多可以详见此题的八境界做法，这里只阐述A*与IDA*算法。

    A*算法:

    简单来说是带估值函数的广搜。不同之处在于:对每个放入队列(open table)的节点计算估值函数h(x)，然后进行排序。这样出队时的顺序就不是自然顺序，而是有导向性的一个顺序，这样可以比直接搜索能更快的到达目标节点。

   缺点：A*算法与bfs一样，都是搜索当前节点下，下一步的所有走法，所以需要耗费大量的空间来存储节点。

   优点:同样的估值函数，a*找到的应该是较短路(至于是不是最短路，我觉得应该要看估值函数的选择)

 

//140ms
#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>
#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<n;++i){
        temp=0;
        for(j=i+1;j<n;++j){
            if(s[j]<s[i])
                temp++;
        }
        num+=fac[n-1-i]*temp;
    }
    return num;
}
void CantorReverse(int index,int *t,int n){///逆康托展开
    index--;///注意index表示第几个，index>=1
    int i,j;
    bool hash[10]={0};
    for(i=0;i<n;++i){
        int tmp=index/fac[n-1-i];
        for(j=0;j<=tmp;++j)
            if(hash[j]) tmp++;
        t[i]=tmp+1;
        hash[tmp]=1;
        index%=fac[n-1-i];
    }
    return;
}
bool can[362880];
char ans[362880][42];
int target[]={1,2,3,4,5,6,7,8,0};
int tt[9];
struct node{
    int key,x,y,tol;
    node(int _key,int _x,int _y,int _tol):key(_key),x(_x),y(_y),tol(_tol){}
};
queue<node> 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<tmp.tol;++i) ans[tkey][i]=ans[tmp.key][i];
                ans[tkey][tmp.tol]='d';
                ans[tkey][tmp.tol+1]='\0';
            }
            swap(tt[x*3+y],tt[(x-1)*3+y]);
        }
        if(y>=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<tmp.tol;++i) ans[tkey][i]=ans[tmp.key][i];
                ans[tkey][tmp.tol]='r';
                ans[tkey][tmp.tol+1]='\0';
            }
            swap(tt[x*3+y],tt[x*3+y-1]);
        }
        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<tmp.tol;++i) ans[tkey][i]=ans[tmp.key][i];
                ans[tkey][tmp.tol]='u';
                ans[tkey][tmp.tol+1]='\0';
            }
            swap(tt[x*3+y],tt[(x+1)*3+y]);
        }
        if(y<=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<tmp.tol;++i) ans[tkey][i]=ans[tmp.key][i];
                ans[tkey][tmp.tol]='l';
                ans[tkey][tmp.tol+1]='\0';
            }
            swap(tt[x*3+y],tt[x*3+y+1]);
        }
    }
}
int d[9];
void solve(){
    int tkey=Cantor(d,9);
    if(!can[tkey]){printf("unsolvable\n");return;}
    int len=strlen(ans[tkey]);
    for(int i=len-1;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<cstdio>
#include<cmath>
#include<algorithm>
#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:"<<depth<<endl;
        }
        printf("%s\n",s);
    }
}

附带一个逆序数奇偶剪枝的证明:https://blog.csdn.net/u011008379/article/details/40144147