1. 程式人生 > >hdu1043 Eight(A*/雙向BFS/單項BFS打表+康託展開)

hdu1043 Eight(A*/雙向BFS/單項BFS打表+康託展開)

題意描述:經典八數碼問題,給定八數碼的初始序列,求經過u、r、l、d四種操作到達1 2 3 4 5 6 7 8 x的狀態,打印出操作序列?

解題思路:A*/雙向BFS/單項BFS打表+康託展開   202msAC

方法一:BFS逆向打表+康託展開:從1 2 3 4 5 6 7 8 x逆向擴充套件,記錄哪些狀態可以到達,以及到達給狀態操作

程式碼:

#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;
}

方法二:A*(h(x):曼哈頓距離)+奇偶剪枝(逆序數)+康拓展開 560ms

分析:

1、首先移動x時序列(把x除外)的逆序數奇偶性不會發生變化,左右移動序列不變,上下移動每次某個數會向前移動兩位或向後移動兩位逆序數+2,所以奇偶性不變

2、給定一個序列我們可以發現要到達目標序列:1 2 3 4 5 6 7 8 x至少需要的距離為當前序列每個數移動到目標序列中該數的位置的步數之和,故可以以此作為估計函式

3、判斷是否重複出現可以使用康拓展開

程式碼:

#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>
#include <cmath>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
int fac[]={1,1,2,6,24,120,720,5040,40320};
int nextx[]={-1,0,1,0},nexty[]={0,1,0,-1};
char nextop[]={'u','r','d','l'};
int tx[]={2,0,0,0,1,1,1,2,2},ty[]={2,0,1,2,0,1,2,0,1};
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;
}
bool can[362880];
int pre[362880];
char charop[362880];
int tt[9];
struct node{
    int xx[9];
    int key,x,y;
    int d,h;
    node(){}
    node(int _key,int _x,int _y,int _d,int _h):key(_key),x(_x),y(_y),d(_d),h(_h){}
    bool operator<(const node& b)const{
        return (d+h)>(b.d+b.h);
    }
};
int geth(int* tt){
    int h=0;
    for(int i=0;i<9;++i){
        if(tt[i])
            h+=abs(i/3-tx[tt[i]])+abs(i%3-ty[tt[i]]);
    }
    return h;
}
int target;
char ans[100];
int anstol;
int d[9],tg[]={1,2,3,4,5,6,7,8,0};
void bfs(int s,int x,int y){
    mem(can,false);
    priority_queue<node> q;
    can[s]=true;
    pre[s]=-1;
    node tmp(s,x,y,0,geth(d));
    for(int i=0;i<9;++i) tmp.xx[i]=d[i];
    q.push(tmp);
    while(!q.empty()){
        tmp=q.top();q.pop();
        if(tmp.key==target){
            anstol=0;
            int key=target;
            while(pre[key]!=-1){
                ans[anstol++]=charop[key];
                key=pre[key];
            }
            for(int i=anstol-1;i>=0;--i)
                printf("%c",ans[i]);
            printf("\n");
            return;
        }
        node v;
        for(int i=0;i<4;++i){
            v.x=tmp.x+nextx[i],v.y=tmp.y+nexty[i];
            for(int i=0;i<9;++i) v.xx[i]=tmp.xx[i];
            if(v.x>=0&&v.x<=2&&v.y>=0&&v.y<=2){
                swap(v.xx[tmp.x*3+tmp.y],v.xx[v.x*3+v.y]);
                v.key=Cantor(v.xx,9);
                if(!can[v.key]){
                    v.d=tmp.d+1;
                    v.h=geth(v.xx);
                    pre[v.key]=tmp.key;
                    charop[v.key]=nextop[i];
                    can[v.key]=true;
                    q.push(v);
                }
            }
        }
    }
    printf("unsolvable\n");
}
bool ischeck(){
    int flag=0;
    for(int i=0;i<9;++i){
        if(d[i]==0) continue;
        for(int j=i+1;j<9;++j){
            if(d[j]&&d[i]>d[j]) flag++;
        }
    }
    if(flag%2) return true;
    return false;
}
char op[3];
int main(){
    target=Cantor(tg,9);
    while(scanf("%s",op)!=EOF){
        int i,x,y;
        for(i=0;i<=7;++i){
            if(op[0]=='x') {d[i]=0;x=i/3;y=i%3;}
            else d[i]=op[0]-'0';
            scanf("%s",op);
        }
        if(op[0]=='x') {d[i]=0;x=i/3;y=i%3;}
        else d[i]=op[0]-'0';
        if(ischeck()) {printf("unsolvable\n");continue;}
        bfs(Cantor(d,9),x,y);
    }
    return 0;
}

方法三:雙向BFS+奇偶剪枝+康託展開 546ms

程式碼:

#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>
#include <cmath>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
int fac[]={1,1,2,6,24,120,720,5040,40320};
int nextx[]={-1,0,1,0},nexty[]={0,1,0,-1};
char preop[]={'u','r','d','l'};
char nextop[]={'d','l','u','r'};
int tx[]={2,0,0,0,1,1,1,2,2},ty[]={2,0,1,2,0,1,2,0,1};
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;
}
bool can1[362880],can2[362880];
int pre[362880],nexts[362880];
char savepop[362880],savenop[362880];
struct node{
    int tt[9],key;
    int x,y;
    int h;///以擴充套件深度選擇擴充套件那個佇列(擴充套件深度淺的,效能略好),也可以佇列內元素的多少為依據(擴充套件少的)
    node(){}
};
int geth(int* tt){
    int h=0;
    for(int i=0;i<9;++i){
        if(tt[i])
            h+=abs(i/3-tx[tt[i]])+abs(i%3-ty[tt[i]]);
    }
    return h;
}
char ans[100];
int anstol;
int s[9],t[]={1,2,3,4,5,6,7,8,0};
int source,target;
void print(int key){
    int tkey=key;
    anstol=0;
    while(pre[tkey]!=-1){
        ans[anstol++]=savepop[tkey];
        tkey=pre[tkey];
    }
    for(int i=anstol-1;i>=0;--i)
        printf("%c",ans[i]);
    tkey=key;
    while(nexts[tkey]!=-1){
        printf("%c",savenop[tkey]);
        tkey=nexts[tkey];
    }
    printf("\n");
    return;
}
void bfs(int x,int y){
    queue<node> q1,q2;
    mem(can1,false);mem(can2,false);
    can1[source]=true;
    can2[target]=true;
    pre[source]=-1;
    nexts[target]=-1;
    node tmp;
    tmp.key=source;tmp.x=x;tmp.y=y;tmp.h=0;
    for(int i=0;i<9;++i) tmp.tt[i]=s[i];
    q1.push(tmp);
    tmp.key=target;tmp.x=2;tmp.y=2;tmp.h=0;
    for(int i=0;i<9;++i) tmp.tt[i]=t[i];
    q2.push(tmp);
    int flag;
    while(!q1.empty()||!q2.empty()){
        if(!q1.empty()&&(q2.empty()||(q1.front().h<q2.front().h))){
            flag=1;tmp=q1.front();q1.pop();
            if(can2[tmp.key]) {print(tmp.key);return;}
        }
        else{
            flag=2;tmp=q2.front();q2.pop();
            if(can1[tmp.key]) {print(tmp.key);return;}
        }
        node v;
        for(int i=0;i<4;++i){
            v.x=tmp.x+nextx[i],v.y=tmp.y+nexty[i];
            for(int j=0;j<9;++j) v.tt[j]=tmp.tt[j];
            if(v.x>=0&&v.x<=2&&v.y>=0&&v.y<=2){
                swap(v.tt[tmp.x*3+tmp.y],v.tt[v.x*3+v.y]);
                v.key=Cantor(v.tt,9);
                v.h=tmp.h+1;
                if(flag==1&&!can1[v.key]){
                    pre[v.key]=tmp.key;
                    savepop[v.key]=preop[i];
                    if(can2[v.key]) {print(v.key);return;}
                    can1[v.key]=true;
                    q1.push(v);
                }
                else if(flag==2&&!can2[v.key]){
                    nexts[v.key]=tmp.key;
                    savenop[v.key]=nextop[i];
                    if(can1[v.key]) {print(v.key);return;}
                    can2[v.key]=true;
                    q2.push(v);
                }
            }
        }
    }
    printf("unsolvable\n");
}
bool ischeck(){
    int flag=0;
    for(int i=0;i<9;++i){
        if(s[i]==0) continue;
        for(int j=i+1;j<9;++j){
            if(s[j]&&s[i]>s[j]) flag++;
        }
    }
    if(flag%2) return true;
    return false;
}
char op[3];
int main(){
    target=Cantor(t,9);
    while(scanf("%s",op)!=EOF){
        int i,x,y;
        for(i=0;i<=7;++i){
            if(op[0]=='x') {s[i]=0;x=i/3;y=i%3;}
            else s[i]=op[0]-'0';
            scanf("%s",op);
        }
        if(op[0]=='x') {s[i]=0;x=i/3;y=i%3;}
        else s[i]=op[0]-'0';
        if(ischeck()) {printf("unsolvable\n");continue;}
        source=Cantor(s,9);
        bfs(x,y);
    }
    return 0;
}