八数码[POJ1077 | HDU1043] BFS A* IDA* 双广

　　八数码问题，对于一般的数据，BFS+逆序对HASH就可以解决了，或者双广搜索。进一步的话就是A*优化，A*的启发函数有以下两种：1,不在相应位置的格子数目;  2,不在相应位置的曼哈顿距离之和;显然第二种的效率比较高。一中兼顾效率，写起来有方便的算法就是IDA*，因为不要判重，而且是DFS，代码量小。还有猥琐点的方式就是从目标状态向所有状态扩展打表。。。

　　对于八数码问题，还有一个重要剪枝，那就是逆数对的剪枝，如果开始状态的逆数对数目是奇数则必无解，否则一定有解。因为对于目标状态的逆序对是0，即偶数，而操作只能与0交换，而0是不会影响结果的，只有于0交换的数会影响结果，但是那个数移动也会没有影响，因此初始状态逆序对数为奇数不可能会转到偶数的状态，因此无解。

　　其中对于POJ-1077和HDU-1043这两道题，因为只要求出可行解，没有必要求出步数最少的解，因此我们完全可以自己构造解，相信玩过拼图游戏并且思考了的就是小case了，简而言之就是一个一个的按照1,2,,,8,0的顺序把格子放回原位并且固定，再去放其它的，直到目标状态为止。

　　下面是我的HDU1043 A*代码：

//STATUS:C++_AC_328MS_4744KB
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
//define
#define pii pair<int,int>
#define mem(a,b) memset(a,b,sizeof(a))
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define PI acos(-1.0)
//typedef
typedef long long LL;
typedef unsigned long long ULL;
//const
const int N=210;
const int INF=0x3f3f3f3f;
const int MOD=1000007,STA=400010;
const LL LNF=1LL<<60;
const double EPS=1e-8;
const double OO=1e15;
const int dx[4]={-1,0,1,0};
const int dy[4]={0,1,0,-1};
//Daily Use ...
template<class T> inline T Min(T a,T b){return a<b?a:b;}
template<class T> inline T Max(T a,T b){return a>b?a:b;}
template<class T> inline T Min(T a,T b,T c){return min(min(a, b),c);}
template<class T> inline T Max(T a,T b,T c){return max(max(a, b),c);}
//End

char out[]="urdl";
int fac[10];
int T,end;

struct Path{
    int op,fa;
}path[STA];

struct Node{
    int ma[9];
    int sta,g,h,x,y;
    bool operator < (const Node& b)const{
        return h!=b.h?h>b.h:g>b.g;
    }
};

struct HASH{
    int sta[STA];
    void init(){mem(sta,0);}
    int ctadd(int s[]){
        int i,j,ret=0,k;
        for(i=0;i<9;i++){
            for(j=k=0;j<i;j++)
                if(s[j]>s[i])k++;
            ret+=k*fac[i];
        }
        if(sta[ret])return -1;
        sta[ret]=1;
        return ret;
    }
}hs;

int geth(int s[])
{
    int i,j,h=0,x,y;
    for(i=0;i<3;i++){
        for(j=0;j<3;j++){
            x=s[i*3+j]/3;
            y=s[i*3+j]%3;
            h+=abs(x-i)+abs(y-j);
        }
    }
    return h;
}

int isok(int s[])
{
    int i,j,cnt;
    for(i=cnt=0;i<9;i++){
        for(j=i+1;j<9;j++)
            if(s[i]!=8 && s[j]!=8 && s[i]>s[j])cnt++;
    }
    return !(cnt&1);
}

int astar(int s[])
{
    int i,j;
    Node u,v;
    priority_queue<Node> q;
    for(i=0;i<9;i++)u.ma[i]=s[i];
    u.sta=hs.ctadd(s);
    u.g=0;u.h=geth(s);
    for(i=0;i<9;i++)if(s[i]==8){u.x=i/3,u.y=i%3;break;}
    q.push(u);
    path[u.sta].fa=-1;
    while(!q.empty()){
        u=q.top();q.pop();
        for(i=0;i<4;i++){
            v.x=u.x+dx[i];
            v.y=u.y+dy[i];
            if(v.x>=0&&v.x<3 && v.y>=0&&v.y<3){
                for(j=0;j<9;j++)v.ma[j]=u.ma[j];
                v.ma[v.x*3+v.y]=u.ma[u.x*3+u.y];
                v.ma[u.x*3+u.y]=u.ma[v.x*3+v.y];
                v.sta=hs.ctadd(v.ma);
                if(v.sta>=0){
                    path[v.sta].op=i;
                    path[v.sta].fa=u.sta;
                    v.g=u.g+1;
                    v.h=geth(v.ma);
                    q.push(v);
                }
                if(v.sta==end){
                    return v.sta;
                }
            }
        }
    }
    return -1;
}

void print(int u)
{
    if(path[u].fa==-1)return;
    print(path[u].fa);
    printf("%c",out[path[u].op]);
}

int main()
{
 //   freopen("in.txt","r",stdin);
    int i,j,s[10],ans;
    char c[N];
    fac[0]=1;
    for(i=1;i<9;i++)fac[i]=i*fac[i-1];
    end=0;

    while(gets(c)){
        for(i=j=0;c[i];i++){
            if(c[i]!=' '){
                if(c[i]=='x')s[j]=8;
                else s[j]=c[i]-'1';
                j++;
            }
        }

        for(i=0,j=1;i<9;i++)if(s[i]!=i){j=0;break;}
        if(j){
            putchar('\n');
            continue;
        }
        if(isok(s)){
            hs.init();
            ans=astar(s);
            print(ans);
        }
        else printf("unsolvable");
        putchar('\n');
    }
    return 0;
}