hdu1043八数码的八境界

大学一年了什么都不会，最近又什么都不想学，可是离正式打比赛还有仅仅半年，咨询了好多个学长我现在该学什么，如何静下心学习。考虑了好九八，决定步上jh学长的后路学习一下A*搜索。那么接下来开始？！

---

写之前拜读了这篇文章:八数码的八境界
代码是hdu1043八数码 bfs 打表/双向bfs/A*+康托判重+逆序奇偶剪枝
本文版权归原作者、译者所有;如果侵害到您的权益，请联系我，我将删除本文。

境界一、 暴力广搜+STL

我们从{1,2,3,4,5,6,7,8,x}这个状态开始搜索，利用bfs跑遍每一种状态，并将path记录，复杂度9!，查询O(1)
判重我们利用set的find()函数
set红黑树实现，查找效率log(n);总的效率nlog(n)（10^6），肯定会TLE
丑陋的代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<set>
#include<map>
#include<queue>
#include<vector>
#include<string>
using namespace std;

struct node{
    string sty;//状态
    string path;//路径
    int pos;//x的位置
    node(string sty,string path,int pos):sty(sty),path(path),pos(pos){}
};

map<string,string>res;
set<string>vis;
int to[4][2]={-1,0,1,0,0,-1,0,1};
string dir("durl");//4个方向对应的操作

bool check(int x,int y){
    return x>=0&&x<=2&&y>=0&&y<=2;
}

void bfs(){
    queue<node>q;
    node n("12345678x","",8);
    vis.insert("12345678x");
    q.push(n);
    while(!q.empty()){
        n=q.front();
        q.pop();
        int x=n.pos/3;
        int y=n.pos%3;
        for(int i = 0; i < 4; i++){
            int newx=x+to[i][0];
            int newy=y+to[i][1];
            if(!check(newx,newy))continue;
            int newpos=newx*3+newy;
            swap(n.sty[n.pos],n.sty[newpos]);//交换当前x与移动后的x位置
            if(vis.find(n.sty)!=vis.end()){//set查重
                swap(n.sty[n.pos],n.sty[newpos]);//换回防止在判断下一个方向时，改变了原始的状态
                continue;
            }
            else{
                q.push(node(n.sty,dir[i]+n.path,newpos));
                vis.insert(n.sty);
                res[n.sty]=dir[i]+n.path;
                swap(n.sty[n.pos],n.sty[newpos]);
            }
        }
    }
}

int main(){
    string in;
    string tmp;
    res[in]="";
    bfs();
    while(cin>>tmp){
        in.push_back(tmp[0]);
        for(int i = 1; i < 9; i++){
            cin>>tmp;
            in.push_back(tmp[0]);
        }
        if(res[in]=="")printf("unsolvable\n");
        else cout<<res[in]<<endl;
    }
    return 0;
}

由于path是由结构体存储，也会Mle

境界二、广搜+哈希

T 是由于大规模的遍历，已经set的查重和string的使用，那么我们可以利用哈希进行o(1)的查重
这里哈希是利用康托展开和逆康托展开并且由之前的string记录路径改为char记录，并且利用前驱记录由哪个状态改变而来

path[s.status].from=parent.stauts

思路与境界三相同所以代码也在三给出

境界三、广搜+哈希+打表

与其每一组进行一次bfs，不如直接由目标状态{1，2，3，4，5，6，7，8，x}直接打表并O(1)查询
别人借鉴过来的不丑陋！
出处

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<queue>
#include<cstring>
#include<string>
using namespace std;

const int maxn = 362880+5;
int fac[9];
int vis[maxn];
int to[4][2]={-1,0,1,0,0,-1,0,1};
char dir[]="durl";

struct node{
    int pos,status;
    node(int pos,int status):pos(pos),status(status){}
};

struct path{
    int from,dir;
}p[maxn];

void calFac(int f[],int n){
    f[0]=1;
    for(int i = 1; i < n; i++)f[i]=f[i-1]*i;
}

int encodeCantor(int s[]){
    int i,j,temp,num;
    num=0;
    for(int i = 0; i < 9; i++){
        temp=0;
        for(int j = i+1; j < 9; j++){
            if(s[i]>s[j])temp++;
        }
        num+=temp*fac[8-i];
    }
    return num;
}

void decodeCantor(int s[],int val){
    bool flag[10];
    memset(flag,0,sizeof flag);
    for(int i = 0; i < 9; i++){
        int temp=val/fac[8-i];
        for(int j = 0; j <=temp; j++){
            if(flag[j])temp++;
        }
        s[i]=temp;
        flag[temp]=1;
        val=val%fac[8-i];
    }
}

bool check(int x,int y){
    return x>=0&&y>=0&&x<=2&&y<=2;
}

void bfs(){
    queue<node>q;
    int s[]={1,2,3,4,5,6,7,8,0};
    node n(8,encodeCantor(s));
    vis[n.status]=1;
    p[n.status].from=-1;
    q.push(n);
    while(!q.empty()){
        n=q.front();q.pop();
        int x=n.pos/3,y=n.pos%3;
        for(int i = 0; i < 4; i++){
            int newx=x+to[i][0];
            int newy=y+to[i][1];
            if(!check(newx,newy))continue;
            int newpos = newx*3+newy;
            decodeCantor(s,n.status);
            swap(s[n.pos],s[newpos]);
            int nstatus = encodeCantor(s);
            if(!vis[nstatus]){
                p[nstatus].from=n.status;
                p[nstatus].dir=i;
                vis[nstatus]=1;
                q.push(node(newpos,nstatus));
            }
            swap(s[n.pos],s[newpos]);
        }
    }
}

void print(int s){
    while(p[s].from != -1){
        printf("%c",dir[p[s].dir]);
        s=p[s].from;
    }
    printf("\n");
}

void init(){
    calFac(fac,9);
    memset(vis,0,sizeof vis);
}

int main(){
    init();
    bfs();
    string tmp;
    int in[9];
    while(cin>>tmp){
        if(tmp[0]=='x')in[0]=0;
        else in[0]=tmp[0]-'0';
        for(int i = 1; i < 9; i++){
            cin>>tmp;
            if(tmp[0]=='x')in[i]=0;
            else in[i]=tmp[0]-'0';
        }
        int status = encodeCantor(in);
        if(!vis[status])printf("unsolvable\n");
        else
            print(status);
    }
    return 0;
}

境界四、双向广搜+哈希

减少状态膨胀，即用双向bfs

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;

const int maxn = 362880+7;
int to[4][2]={-1,0,1,0,0,-1,0,1};
char dir1[]={"udlr"};
char dir2[]={"durl"};

struct node{
    int status,pos;
};

int p1[maxn],p2[maxn];
int d1[maxn],d2[maxn];
bool vis1[maxn],vis2[maxn];
int fac[9];

void init(){
    fac[0]=1;
    for(int i = 1; i < 9; i++)fac[i]=fac[i-1]*i;
}

int encodeCantor(int s[]){
    int cnt,sum=0;
    for(int i = 0; i < 9; i++){
        cnt=0;
        for(int j = i+1; j < 9; j++)
            if(s[i]>s[j])cnt++;
        sum+=fac[8-i]*cnt;
    }
    return sum;
}

void decodeCantor(int a[],int s){
    bool flag[9];
    memset(flag,0,sizeof flag);
    for(int i = 0; i < 9; i++){
        int cnt=s/fac[8-i];
        for(int j = 0; j <= cnt; j++){
            if(flag[j])cnt++;
        }
        a[i]=cnt;
        flag[cnt]=1;
        s=s%fac[8-i];
    }
}

bool check(int x,int y){
    return x>=0&&y>=0&&x<=2&&y<=2;
}

void print(int status){
    int s = status;
    char tmp[36];int len = 0;
    while(p1[s]!=-1){
        tmp[len++]=dir1[d1[s]];
        s=p1[s];
    }
    s = status;
    for(int i = len-1; i >= 0; i--)printf("%c",tmp[i]);
    while(p2[s]!=-1){
        printf("%c",dir2[d2[s]]);
        s=p2[s];
    }
    printf("\n");
}

void bfs(int po,int sta){
    queue<node>q1,q2;
    memset(vis1,0,sizeof vis1);
    memset(vis2, 0 , sizeof vis2);
    int arr[9];
    int aim[]={1,2,3,4,5,6,7,8,0};
    int aim_s=encodeCantor(aim);
    node n;
    n.status = sta;
    n.pos=po;
    q1.push(n);
    n.status=aim_s;
    n.pos=8;
    q2.push(n);

    node cur,next;

    p1[sta]=-1;
    p2[aim_s]=-1;
    vis1[sta]=1;
    vis2[aim_s]=1;

    int flag;
    while(!q1.empty()||!q2.empty()){
        if(!q1.empty()&&(q2.empty()||q1.size()<=q2.size())){
            flag=1;
            cur=q1.front();
            q1.pop();
            if(vis2[cur.status]){
                print(cur.status);
                return ;
            }
        }

        else{
            flag=2;
            cur=q2.front();
            q2.pop();
            if(vis1[cur.status]){
                print(cur.status);
                return ;
            }
        }
        decodeCantor(arr,cur.status);
        int x=cur.pos/3,y=cur.pos%3;
        for(int i = 0; i < 4; i++){
            int nx=x+to[i][0],ny=y+to[i][1];
            if(!check(nx,ny))continue;
            int newpos=nx*3+ny;
            swap(arr[cur.pos],arr[newpos]);
            int nstatus = encodeCantor(arr);
            if(flag==1&&!vis1[nstatus]){
                p1[nstatus]=cur.status;
                d1[nstatus]=i;
                if(vis2[nstatus]){
                    print(nstatus);
                    return;
                }
                else{
                    vis1[nstatus]=1;
                    next.status=nstatus;
                    next.pos=newpos;
                    q1.push(next);
                }
            }
            else if(flag==2&&!vis2[nstatus]){
                p2[nstatus]=cur.status;
                d2[nstatus]=i;
                if(vis1[nstatus]){
                    print(nstatus);
                    return;
                }
                else{
                    vis2[nstatus]=1;
                    next.pos=newpos;
                    next.status=nstatus;
                    q2.push(next);
                }
            }
            swap(arr[cur.pos],arr[newpos]);
        }
    }
    return ;
}

bool pruning(int arr[]){
    int cnt=0;
    for(int i = 0; i < 9; i++){
        if(arr[i]==0)continue;
        for(int j = i + 1; j < 9; j++){
            if(arr[j]&&arr[j]<arr[i])cnt++;
        }
    }
    if(cnt%2)return true;
    return false;
}

int main(){
    char tmp[3];
    int in[9];
    int pos;
    init();
    while(~scanf("%s",tmp)){
        if(tmp[0]=='x'){
            in[0]=0;
            pos=0;
        }
        else in[0]=tmp[0]-'0';
        for(int i = 1; i < 9; i++){
            scanf("%s",tmp);
            if(tmp[0]=='x'){
                in[i]=0;
                pos=i;
            }
            else in[i]=tmp[0]-'0';
        }
        int status = encodeCantor(in);
        if(pruning(in))printf("unsolvable\n");
        else{
            bfs(pos,status);
        }
    }
    return 0;
}

境界五、A*+哈希+简单估价函数

境界六、A*+哈希+曼哈顿距离

境界七、A*+哈希+曼哈顿距离+小顶堆

直接走境界7？

A算法
理解A寻路算法
启发式算法的估价函数为 f(n) = g(n) + h(n)

G 表示从起点 A 移动到网格上指定方格的移动耗费 (可沿斜方向移动).

H 表示从指定的方格移动到终点 B 的预计耗费 (H 有很多计算方法, 这里我们设定只可以上下左右移动).

A*算法的估价函数可以表示为

f’(n) = g’(n) + h’(n)
f’(n)是估价函数，g’(n)是起点到终点的最短路径值，h’(n)是n到目标的最断路经的启发值。由 于这个f’(n)其实是无法预先知道的，所以我们用估价函数f(n)做近似。g(n)代替g’(n)，但 g(n)>=g’(n) 才可（大多数情况下都是满足的，可以不用考虑），h(n)代替h’(n)，但h(n)<=h’(n)才可（这一点特别的重 要）。

这里的G指的是bfs扩展的层数，因为一层就是一步

H指的是当前位置到终点的曼哈顿距离

计算曼哈顿距离的函数为

---

int tx[]={2,0,0,0,1,1,1,2,2};
int ty[]={2,0,1,2,0,1,2,0,1};

double getH(int a[]){
    int x,y;
    int h = 0;
    for(int i = 0; i < 9; i++){
        if(a[i]){
            x = i / 3;
            y = i % 3;
            h += abs(x-tx[a[i]])+abs(y-ty[a[i]]);
        }
    }
    return h;
}

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int maxn = 362880+7;
int fac[]={1,1,2,6,24,120,720,5040,40320};
int to[4][2]={-1,0,1,0,0,-1,0,1};
char dir[]="udlr";
bool vis[maxn];

struct node{
    int status,pos;
    double g,h;
    bool operator<(const node&n)const{
        return (g+h)>(n.g+n.h);
    }
};

struct path{
    int from,dir;
}p[maxn];

int encodeCantor(int a[]){
    int sum = 0;
    for(int i = 0;i < 9; i++){
        int cnt = 0;
        for(int j = i+1; j < 9; j++)if(a[i]>a[j])cnt++;
        sum+=cnt*fac[8-i];
    }
    return sum;
}

void decodeCantor(int a[],int val){
    int flag[9],cnt=0;
    memset(flag,0,sizeof flag);
    for(int i = 0; i < 9; i++){
        cnt = val / fac[8-i];
        for(int j = 0; j <= cnt; j++){
            if(flag[j])cnt++;
        }
        a[i]=cnt;
        flag[cnt]=1;
        val = val%fac[8-i];
    }
}

int tx[]={2,0,0,0,1,1,1,2,2};
int ty[]={2,0,1,2,0,1,2,0,1};

double getH(int a[]){
    int x,y;
    int h = 0;
    for(int i = 0; i < 9; i++){
        if(a[i]){
            x = i / 3;
            y = i % 3;
            h += abs(x-tx[a[i]])+abs(y-ty[a[i]]);
        }
    }
    return h;
}

bool pruning(int a[]){
    int sum = 0;
    for(int i = 0; i < 9; i++){
        if(!a[i])continue;
        for(int j = i+1; j < 9; j++){
            if(a[j]&&a[i]>a[j])sum++;
        }
    }
    if(sum%2)return true;
    else return false;
}

bool check(int x,int y){
    return x>=0&&y>=0&&x<=2&&y<=2;
}

void A_S(int a[]){
    int aim[]={1,2,3,4,5,6,7,8,0};
    int aim_s=encodeCantor(aim);
    priority_queue<node>que;
    memset(vis,0,sizeof vis);
    node cur,next;
    int status = encodeCantor(a);
    for(int i = 0; i < 9; i++){
        if(!a[i]){
            cur.pos = i;
            break;
        }
    }
    cur.status = status;
    cur.g=0;
    cur.h=getH(a);
    que.push(cur);
    p[status].from = -1;
    vis[status]=1;
    while(!que.empty()){
        cur = que.top();
        que.pop();
        decodeCantor(a,cur.status);
        if(cur.status == aim_s){
            int s = cur.status,len = 0;
            char res[maxn];
            while(p[s].from != -1){
                res[len++]=dir[p[s].dir];
                s=p[s].from;
            }
            for(int i = len-1; i>=0; i--)printf("%c",res[i]);
            printf("\n");
            return ;
        }
        else{
            int x = cur.pos/3,y=cur.pos%3;
            for(int i = 0; i < 4; i++){
                int nx = x + to[i][0],ny = y + to[i][1];
                int newpos=nx*3+ny;
                if(!check(nx,ny))continue;
                swap(a[cur.pos],a[newpos]);
                int nstatus = encodeCantor(a);
                if(!vis[nstatus]){
                    next.pos=newpos;next.status=nstatus;next.g=cur.g+1;next.h=getH(a);
                    p[next.status].from = cur.status;
                    p[next.status].dir = i;
                    vis[nstatus]=1;
                    que.push(next);
                }
                swap(a[cur.pos],a[newpos]);
            }
        }
    }
    printf("unsolvable\n");
}

int main(){
    char tmp[5];
    int in[9];
    while(~scanf("%s",tmp)){
        if(tmp[0]=='x')in[0]=0;
        else in[0]=tmp[0]-'0';
        for(int i = 1; i < 9; i++){
            scanf("%s",tmp);
            if(tmp[0]=='x')in[i]=0;
            else in[i]=tmp[0]-'0';
        }
        if(pruning(in))printf("unsolvable\n");
        else A_S(in);
    }
    return 0;
}