数据结构算法： 八数码问题 小结

好久没写博客了，最近开始更一个系列，关于数据结构算法的，希望能形成一个好的体系。 之前写的博文是零碎的知识点小结，只适合自己回顾，不适合他人阅读或者教学，希望这个系列能改善相关的问题，方便他人阅读，分享知识。

问题定义

• 八数码问题： 在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。所谓问题的一个状态就是棋子在棋盘上的一种摆法。棋子移动后，状态就会发生改变。解八数码问题实际上就是找出从初始状态到达目标状态所经过的一系列中间过渡状态。

• 八数码问题一般使用搜索法来解。搜索法有广度优先搜索法、双向广度优先算法、深度优先搜索法、A*算法等。这里通过用不同方法解八数码问题来比较一下不同搜索法的效果。关于搜索问题，往往重要的是相关的搜索策略的选择。策略选择的好，效率就会有非常大的差异。

• oj题目：PKU(1077) HDOJ(1043) ZOJ(1217) 由于测试数据的不同各平台状态不同

• 变种：hdu 3567等

算法流程：

1. cantor算法+奇偶性判断（或者逆序对数目判断）是否存在解，若有解，转2； 否则退出
2. 根据环境选择搜索策略进行搜索求解，本文以典型的搜索算法： BFS，双向BFS， 离线算法，A*算法为例进行讲解

相关搜索策略

单向BFS搜索

#include<iostream>
#include<cstdio>
#include<cstring>
//#include<vector>
#include<algorithm>
#include<queue>
#include<map>

#ifdef L_JUDGE
#pragma warning(disable:4996)
#endif

using namespace std;
typedef pair<int,char> pic;

struct Node{
    int s[9];
    int ri,ci;
    int status;
    int cnt;
    Node(){
        memset(s,0,sizeof(s));
        ri=ci=0;
        status=-1;
        cnt=0;
    }
};
const int dir[4][2]={-1,0,1,0,0,-1,0,1};

char in[20];
Node st,ed;
queue<Node> Q;
int fac[9];
bool vis[(int)4e5+10];
map<int,pair<int,int> >pre;

bool InMap(int ri,int ci){
    return ri>=0&&ri<3&&ci>=0&&ci<3;
}

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

int BFS(const Node& st,int edval){
    memset(vis,false,sizeof(vis));
    while(!Q.empty())Q.pop();
    pre.clear();
    Q.push(st);
    vis[st.status]=true;
    pre[st.status]=make_pair(-1,-1);
    while(!Q.empty()){
        Node u=Q.front();
        Q.pop();
        if(u.status==edval)return u.cnt;
        for(int di=0;di<4;di++){
             Node v=u;
             v.ri=u.ri+dir[di][0];
             v.ci=u.ci+dir[di][1];
             if(!InMap(v.ri,v.ci))continue;
             int upos=3*u.ri+u.ci;
             int vpos=3*v.ri+v.ci;
             swap(v.s[upos],v.s[vpos]);
             v.status=Cantor(v.s);
             if(vis[v.status])continue;
             vis[v.status]=true;
             v.cnt=u.cnt+1;
             Q.push(v);
             pre[v.status]=make_pair(u.status,di);
             if(v.status==edval)return v.cnt;
        }
    }
    return -1;
}

int main(){
    #ifdef L_JUDGE
        freopen("in.txt","r",stdin);
//      freopen("out.txt","w",stdout);
    #endif
    fac[0]=1;
    for(int i=1;i<9;i++)fac[i]=i*fac[i-1];
    ed.ri=ed.ci=2;
    for(int i=0;i<9;i++){
        ed.s[i]=i+1;
    }
    ed.status=Cantor(ed.s);
    while(cin>>in[0]){
        for(int i=1;i<9;i++)cin>>in[i];
        for(int ri=0;ri<9;ri++){
            if('x'==in[ri]){
                st.s[ri]=9;
                st.ri=ri/3;
                st.ci=ri%3;
            }
            else st.s[ri]=in[ri]-'0';
        }
        st.status=Cantor(st.s);
        st.cnt=0;
        int flag=BFS(st,ed.status);
        if(-1==flag)puts("unsolvable");
        else{
            char ans[1000];
            char ch[5]="udlr";
            int k=ed.status;
            ans[flag]=0;
            while(k!=st.status){
                flag--;
                ans[flag]=ch[pre[k].second];
                k=pre[k].first;
            }
            puts(ans);
        }
    }

    #ifdef L_JUDGE
        fclose(stdin);
        fclose(stdout);
//      system("out.txt");
    #endif

    return 0;
}

双向BFS搜索

#include<iostream>
#include<cstdio>
#include<cstring>
//#include<vector>
#include<algorithm>
#include<queue>



#ifdef L_JUDGE
#pragma warning(disable:4996)
#endif

using namespace std;
const int MAXN=5e5;
const int MAXM=6;
const int MAXS=1025;
const int MOD=1e9+7;

char visited[MAXN];
int father1[MAXN];
int father2[MAXN];
int move1[MAXN];
int move2[MAXN];

struct Status{
     char eight[10];
     int space;
     int status;
};

Status s,s1,s2,t;