HDU-1043：Eight（八数码+bfs（反向或A*））

题目链接：点击打开链接

题目大意：

给你一个3*3的表，中间有0到8  9个数字。每次你可以使用0和其相邻的数字交换。使得最后得到一种题目要求的状态并求出最短路径。

解题思路：

当然想到的就是bfs求最短路径，但是要解决几个问题，用什么存当前的状态，map会超时，所以要用hash，hash可以用康托展开。但是如果裸hash+正向bfs肯定会超时。做法有很多，我这里说两种做法。

第一种是利用A*算法，优先判断某些状态，就可以实现剪枝，但是这样出来的答案样例都过不了，最短路步数都不一样。但是AC了，费解费解。。

更新更新！！！

发现了原来代码错误的地方，估价函数的两个估价值不应该像原来的那样写，用他们的和来表示的话样例就能过了，也没测其他数据，目前应该是这个问题，要用两个关键字的和来估价，而不能用优先级分开估价..以下为正确的代码，错误的地方会注释标出

以下贴代码:

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

int m, n;
int ha[10]={1,1,2,6,24,120,720,5040,40320};
int dx[4] = { -1,1,0,0 };
int dy[4] = { 0,0,-1,1 };
int us[1000000][2];
char a2[30];
int a1[30];
string ans;
struct node
{
    int f[3][3];
    int x;
    int y;
    int h,g;
    bool operator<(const node n1)const{     //优先队列第一关键字为h,第二关键字为g
        return h+g>(n1.h+n1.g);   //注意！！！更新版估价函数
        //return h!=n1.h?h>n1.h:g>n1.g;  原来的估价根据优先级判断 错了，样例没过但A了
    }
    int step;
    int haha;
    string str;  //记录路径
}start,en;
int get_hash(node e)    //得到每种状态所对应的哈希值，用了康托展开。
{
    int a[9],k=0,ans=0;
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
            a[k++]=e.f[i][j];
    }
    for(int i=0;i<9;i++)
    {
        k=0;
        for(int j=0;j<i;j++)
            if(a[j]<a[i]) k++;
        ans=ans+ha[i]*k;
    }
    return ans;
}
string vs(int i)  //记录路径，神奇的办法，原本准备双向bfs，后来发现这样记忆路径搞不出来，遂最终用了单向bfs。
{
    if(i==0)
        return "u";
    else if(i==1)
        return "d";
    else if(i==2)
        return "l";
    else if(i==3)
        return "r";
}
int getH(node n)  //A*算法，计算当前状态和最终状态的差值，记为H
{
    int result = 0 ;
    for(int i = 0 ; i < 3 ; ++i)
    {
        for(int j = 0 ; j < 3 ; ++j)
        {
            if(n.f[i][j])
            {
                int x = (n.f[i][j]-1)/3 , y = (n.f[i][j]-1)%3 ;
                result += abs(x-i)+abs(y-j) ;
            }
        }
    }
    return result ;
}
string bfs()     //单向bfs()过程，用了优化队列，也就是A*算法
{
    priority_queue<node> que;
    que.push(start);
    while(que.size())
    {
        node k=que.top();
        que.pop();
        if(k.haha==en.haha)
            return k.str;
        for(int i=0;i<4;i++)
        {
            node v;
            v=k;
            v.x=k.x+dx[i];
            v.y=k.y+dy[i];
            if(v.x>=0&&v.x<3&&v.y>=0&&v.y<3)
            {
                swap(v.f[k.x][k.y],v.f[v.x][v.y]);
                v.haha=get_hash(v);
                if(us[v.haha][v.step]==1) continue;
                v.h=getH(v);
                v.g++;
                v.str=k.str+vs(i);
                us[v.haha][v.step]=1;
                que.push(v);
                if(v.haha==en.haha)
                    return v.str;
            }
        }
    }
}

int main()
{
    while(scanf(" %c",&a2[0])!=EOF)
    {
        for(int i=1;i<9;i++)
            scanf(" %c",&a2[i]);
        memset(us,0,sizeof(us));
        for(int i=0;i<9;i++)        //预处理得到起始状态和结束状态的哈希值
        {
            if(a2[i]=='x')
                a2[i]='0';
            a1[i]=a2[i]-'0';
        }
        for(int i=0;i<9;i++)
        {
            start.f[i/3][i%3]=a1[i];
            if(a1[i]==0)
            {
                start.x=i/3;
                start.y=i%3;
            }
        }
        start.step=0;
        start.haha=get_hash(start);
        start.h=getH(start);
        start.g=0;
        us[start.haha][0]=1;
        int a3[10]={1,2,3,4,5,6,7,8,0};
        for(int i=0;i<9;i++)
        {
            en.f[i/3][i%3]=a3[i];
            if(a3[i]==0)
            {
                en.x=i/3;
                en.y=i%3;
            }
        }
        en.step=1;
        en.haha=get_hash(en);
        us[en.haha][1]=1;
        en.h=getH(en);
        int sum=0;
        for(int i=0;i<9;i++)
        {
            if(a2[i]=='0')continue;
            for(int j=0;j<i;j++)
            {
                if(a2[j]=='0')continue;
                if(a2[j]>a2[i]) sum++;
            }
        }
        if(sum&1)
            printf("unsolvable\n");
        else
            cout<<bfs()<<endl;
    }
}

第二种做法是反向bfs

妈的，以前刚写这道题的时候还用过反向bfs，当时我还在想这反向bfs有个屁用啊。不跟正向一样嘛，后来做的一道类似的题目启发了我，我擦，反向bfs完全不是那么用的啊。反向bfs实现的是预处理，对所有初始状态打表，所以打完表后可以直接输出结果就是了，唉，自己真的太傻了。不过也不想写了，就直接贴xh学长的代码了，这种方法速度很快，毕竟预处理之后剩下输出是O（1）的，样例也能过，反正比第一种方法快很多就是了，理解起来也比较简单，当时傻了吧唧用什么A*。。。

#include <iostream>  
#include <algorithm>  
#include <cstdio>  
#include <cstring>  
#include <vector>  
#include <queue>  
#include <map>  
using namespace std;  
#define INF 0x3f3f3f3f  
#define mem(a,b) memset((a),(b),sizeof(a))  
  
const int MAXS=362880+3;//9!  
const int MAXN=9;  
const int sup[]={1,1,2,6,24,120,720,5040,40320};//阶乘表，用于康托展开  
int maze[MAXN];//保存棋盘状态的临时数组  
string s;  
char ans[MAXS];//从上一个状态走到当前状态的移动方向  
int path[MAXS];//走到的下一个状态  
queue<int> que;  
int init_id;//最终状态id  
  
int get_id()//康托展开  
{  
    int res=0;  
    for(int i=0;i<9;++i)  
    {  
        int cnt=0;//剩下中第几小  
        for(int j=i+1;j<9;++j)  
            if(maze[j]<maze[i])  
                ++cnt;  
        res+=cnt*sup[8-i];  
    }  
    return res;  
}  
  
void get_statue(int id)//通过康托逆展开生成状态  
{  
    int a[MAXN];//存剩下中第几小  
    bool used[MAXN];//是否已用  
    for(int i=8;i>=0;--i)  
    {  
        used[i]=false;  
        a[8-i]=id/sup[i];  
        id%=sup[i];  
    }  
    int cnt;  
    for(int i=0;i<MAXN;++i)  
    {  
        cnt=0;  
        for(int j=0;j<MAXN;++j)  
            if(!used[j])  
            {  
                if(cnt==a[i])  
                {  
                    maze[i]=j;  
                    used[j]=true;  
                    break;  
                }  
                else ++cnt;  
            }  
    }  
}  
  
void init()//bfs倒推预处理出所有结果  
{  
    mem(path,-1);  
    for(int i=0;i<MAXN;++i)  
        maze[i]=(i==8)?0:i+1;  
    init_id=get_id();  
    que.push(init_id);  
    while(!que.empty())  
    {  
        int now=que.front(); que.pop();  
        get_statue(now);  
        int p=-1;//x的位置  
        for(int i=0;i<MAXN;++i)  
            if(maze[i]==0)  
                p=i;  
        if(p!=0&&p!=3&&p!=6)//x左移  
        {  
            swap(maze[p],maze[p-1]);  
            int next=get_id();  
            if(next!=init_id&&path[next]==-1)//新状态  
            {  
                path[next]=now;  
                ans[next]='r';//因为是倒推，所以方向反向  
                que.push(next);  
            }  
            swap(maze[p],maze[p-1]);  
        }  
        if(p!=2&&p!=5&&p!=8)//x右移  
        {  
            swap(maze[p],maze[p+1]);  
            int next=get_id();  
            if(next!=init_id&&path[next]==-1)  
            {  
                path[next]=now;  
                ans[next]='l';  
                que.push(next);  
            }  
            swap(maze[p],maze[p+1]);  
        }  
        if(p<6)//x下移  
        {  
            swap(maze[p],maze[p+3]);  
            int next=get_id();  
            if(next!=init_id&&path[next]==-1)  
            {  
                path[next]=now;  
                ans[next]='u';  
                que.push(next);  
            }  
            swap(maze[p],maze[p+3]);  
        }  
        if(p>2)//x上移  
        {  
            swap(maze[p],maze[p-3]);  
            int next=get_id();  
            if(next!=init_id&&path[next]==-1)  
            {  
                path[next]=now;  
                ans[next]='d';  
                que.push(next);  
            }  
            swap(maze[p],maze[p-3]);  
        }  
    }  
}  
  
int main()  
{  
    init();  
    cin.sync_with_stdio(false);//取消流同步  
    while(getline(cin,s))  
    {  
        int tmp=0;  
        for(int i=0;i<s.length();++i)  
            if(s[i]!=' ')  
                if(s[i]=='x')  
                    maze[tmp++]=0;  
                else maze[tmp++]=s[i]-'0';  
        int id=get_id();  
        if(id!=init_id&&path[id]==-1)  
            cout<<"unsolvable";  
        while(path[id]!=-1)  
        {  
            cout<<ans[id];  
            id=path[id];  
        }  
        cout<<'\n';  
    }  
      
    return 0;  
}