POJ 1077 && HDU 1043 Eight A*算法,bfs,康托展开,hash 难度:3

http://poj.org/problem?id=1077

http://acm.hdu.edu.cn/showproblem.php?pid=1043

X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0! 其中，a[i]为整数，并且X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0!。这就是康托展开。康拓展开可以用来表示排列状态,对于本题的9个数字的所有排列只需要9位,所有状态总共362880个.对每个状态,我们都能得到一个不重复的状态编号,用这个状态编号可以查重

Astar算法,就是一个给所有状态一个评估函数,优先选取较优状态向下搜的最好优先直接搜索算法,对于本题,我们设F(n)=g(n)+h(n)为估价函数,设g(n)为到达该状态已经走过的步数,h(n)为到最终答案的曼哈顿距离

因为该拼图不能改变除了x以外的数字的逆序数奇偶性,所以若x以外的数字逆序数为奇数,则无法得到答案,直接输出

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cctype>
using namespace std;
const int base[9]={1,1,2,6,24,120,720,5040,40320};
const int dx[4]={1,-1,0,0};
const int dy[4]={0,0,1,-1};
const int maxh=362880;
const int des=0;
struct pnt{
        int maz[3][3];
        int h,g;
        int x,y;
        int hashCode;
        bool operator < (pnt p)const {
                return h+g!=p.h+p.g?h+g>p.h+p.g:g>p.g;
        }
        int gethashcode(){
                int ans=0;
                for(int i=0;i<9;i++){
                        int cnt=0;
                        for(int j=0;j<i;j++){
                                if(maz[j/3][j%3]>maz[i/3][i%3]){
                                        cnt++;
                                }
                        }
                        ans+=base[i]*cnt;
                }
                return hashCode=ans;
        }
        int geth(){
                int ans=0;
                for(int i=0;i<3;i++){
                        for(int j=0;j<3;j++){
                                int t=maz[i][j]-1;
                               if(t<9) ans+=abs(i-t/3)+abs(j-t%3);
                        }
                }
                return ans;
        }
        bool judge(){
                int cnt=0;
                for(int i=0;i<9;i++){
                        for(int j=0;j<i;j++){
                                if(maz[i/3][i%3]<9&&maz[j/3][j%3]<9&&maz[i/3][i%3]<maz[j/3][j%3])cnt++;
                        }
                }
                return (cnt&1)==0;
        }
};
bool in(int tx,int ty){
        return tx>=0&&tx<3&&ty>=0&&ty<3;
}

int vis[maxh+1];
int pre[maxh+1];

void astar(pnt s){
        priority_queue <pnt>que;
        que.push(s);
        while(!que.empty()){
                pnt f=que.top();que.pop();
                for(int i=0;i<4;i++){
                        pnt t=f;
                        t.x+=dx[i];
                        t.y+=dy[i];
                        if(in(t.x,t.y)){
                                swap(t.maz[t.x][t.y],t.maz[f.x][f.y]);
                                t.hashCode=t.gethashcode();
                                if(vis[t.hashCode]==-1){
                                        vis[t.hashCode]=i;
                                        t.g++;
                                        pre[t.hashCode]=f.hashCode;
                                        t.h=t.geth();
                                        que.push(t);
                                }
                                if(t.hashCode==des)return ;
                        }
                }
        }
}
char ans[maxh+1];
void print(){
        int nxt=des;
        int len=0;
        while(pre[nxt]!=-1){
               switch(vis[nxt]){
               case 0:
                       ans[len++]='d';
                break;
               case 1:
                       ans[len++]='u';
                break;
               case 2:
                       ans[len++]='r';
                break;
               case 3:
                       ans[len++]='l';
                break;
               }
               nxt=pre[nxt];
        }
        for(int i=len-1;i>=0;i--){
                putchar(ans[i]);
        }
        puts("");
}
char buff[300];
pnt s;
bool input(){
        if(gets(buff)==NULL)return false;
        int j=0;
        for(int i=0;i<9;i++){
                while(!isalnum(buff[j])){j++;}
                if(buff[j]>='0'&&buff[j]<='9'){
                        s.maz[i/3][i%3]=buff[j]-'0';
                }
                else{
                        s.maz[i/3][i%3]=9;
                        s.x=i/3;
                        s.y=i%3;
                }
                j++;
        }
        return true;
}
int main(){
        while(input()){
                memset(vis,-1,sizeof(vis));
                memset(pre,-1,sizeof(pre));
                if(!s.judge()){
                        puts("unsolvable");
                        continue;
                }
                s.hashCode=s.gethashcode();
                if(s.hashCode==des){
                        puts("");
                        continue;
                }
                vis[s.hashCode]=-2;
                s.g=0;s.h=s.geth();
                astar(s);
                print();
        }
        return 0;
}