八数码

题面 这是一道提高组的经典题目而我这个蒟蒻不会！

题目描述

在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。

输入

输入初试状态，一行九个数字，空格用0表示

输出

只有一行，该行只有一个数字，表示从初始状态到目标状态需要的最少移动次数(测试数据中无特殊无法到达目标状态数据)

样例输入

283104765

样例输出

4

题目理解：

可以理解为0-8这么9个数填进九宫格，然后只有0能和其他数互换改变九宫格状态，
希望得到一种状态到另一种状态的最小步数，
其中还有无解的情况。
题目不难理解，用bfs

bfs 不懂自行度娘。

题目分析：

 非常经典的一道广搜题（不过深搜应该也是可以的），另外无解的情况需要另作考虑（如果希望程序全部搜完在输出无解的话有点悬...）。

【问题1：如何广搜】

首先编号为0的状态进入队列，对队首0进行扩展，得到123三个点，全部进队(当然要先检查过这三个点是否能入队，并且一入队就检查是不是目标)，至此队列里是0123，然后123进队了但都不是目标，0也扩展完了，于是0就可以滚了，队首变成了1，继续扩展队首得到4，检查合法性后入队，入队后检查是否是目标，至此队列里是1234，此时4作为1唯一的结点已经没有别的兄弟了，所以1也可以滚了，扩展2，如此循环。

这里再把思路理一理，循环体中主要有两个操作，第一是扩展队首并把儿子入队，第二是每次有入队都判断是否是目标，具体的什么查重啊查合法性啊都可以自己去完善。

【问题2：如何知道到达当前状态的步数】

由搜索图可知:层数即步数，而广搜是按照层数来的，所以搜索到的第一个必定是最优值，出于这个原因广搜总是被用来寻找最短路之类的值。所以在每个状态中只需多一个步数状态，每次扩展便将这步数状态加1即可，具体可以利用结构体存储状态。

扩展一下，如果不单单想找到最短步数，同时还想知道最短路径怎么办：这里利用子结点指向父节点的指针实现。如结点1可扩展出234，那个创建int数组f，让f[2],f[3],f[4]都等于1，代表234都指向1，让f[1]等于1代表1是根结点，于是可以由任意状态找到根节点，期间还可以记录路径，计算步数。

【问题3:状态如何表示】??? 这是最难的！

状态表示最暴力的方法就是开一个数组，但是写代码就比较麻烦了。这里采用一种简单理解的方法，9宫格其实可以看成一个9位数，如123456780就可以看成第一行123第二行456第三行780，具体的换数可以在函数里自己写。

然而这里又遇到麻烦了，在搜索时，我们需要进行判重，那么这个状态怎么判断是否出现过呢？最常规的方法自然是用bool数组标记，但这个9位数最大达到了876543210，无论如何开不下这么大的数组，那怎么办？

最简单则使用map大法。

先放出hash,map两种方法结合的代码（可能说错了！老师写的）

#include<cstdio>
#include<cmath>
#include<queue>
//#include<map>
#define MOD 1000007
using namespace std;
int t = 123804765, s;
struct FLY{
    int s, t;
};
int f[1000039];
int has(int v){ //哈希做法，没有解决冲突
    return v % MOD;
}
//map<int, bool> f; //map做法
queue<FLY> q;
int ex(int h, int i) //将状态h进行扩展，i的0123代表4个方向
{
    int g = 1;
    int r;
    while((int)(h / pow(10, g-1)) % 10 != 0) //g代表0所在位置
        g++;
    if(i == 1){ //将g与上下左右4个方向的数字呼唤，妥善运用/与%
        if(g > 6)return h;
        else{
            r = (int)(h / pow(10, g+2)) % 10;
            return h - r * pow(10, g+2) + r * pow(10,g-1);
            }
    }
    if(i == 2){
        if(g < 4)return h;
        else{
            r = (int)(h / pow(10, g-4)) % 10;
            return h - r * pow(10, g-4) + r * pow(10,g-1);
        }
    }
    if(i == 0){
        if(g % 3 == 0)return h;
        else{
            r = (int)(h / pow(10, g))% 10;
            return h - r * pow(10, g) + r * pow(10,g-1);
        }
    }
    if(i == 3){
        if((g-1) % 3 == 0)return h;
        else{
            r = (int)(h / pow(10, g-2)) % 10;
            return h - r * pow(10, g-2) + r * pow(10,g-1);
        }
    }
}
void bfs(){
    FLY c, h, tmp;
    c.s = s;
    c.t = 0;
    q.push(c);
    while(!q.empty()){ //广搜的模板
        h.s = q.front().s;
        h.t = q.front().t;
        if(h.s == t){
            printf("%d", h.t);
            break;
        }
        for(int i = 0; i < 4; i++){ //4个方向扩展，判重后入队
            tmp.s = ex(h.s, i);
            tmp.t = h.t+1;
            if(!f[has(tmp.s)]){
                q.push(tmp);
                f[has(tmp.s)] = 1;
            }
        }
        q.pop();
    }
}
int main() {
    scanf("%d", &s);
    bfs();
    return 0;
}

添加的代码很多也没办法这是最优解

祝大家RP++；

OVER！

                                                                                                                               #### 2018年12月19日

转载于:https://www.cnblogs.com/wangshengjun/p/bashuma.html