八数码问题（bfs广度优先搜索）

最近在学bfs，觉得这个题不错，自己没做出来，去网上搜了一下，又结合了我自己的想法，ac了；

这个看起来用dfs比较好做，但是会超时好像，所以肯定用bfs了。

问题描述：

　　在九宫格里放在1到8共8个数字还有一个是x，与x相邻的数字可以移动到x的位置，问给定的状态最少需要几步能到达目标状态：

　　1 2 3

       4 5 6

       7 8 x

输入：

　　输入一个初始状态；

输出：

　　到达目标状态所需要的最少步数；

样例：

　　输入：

　　　　1 2 3

　　　　x 4 6

　　　　7 5 8

　　输出：

　　　　19

 

思路：

　　首先，可以根据输入的初始状态直接判断此题是否有解，无解的情况直接输出-1就ok了；

　　具体方法是：将输入的九个数存到一个一维数组，假设f（1）为数字1在数组位置中在1前面比1小的数，

　　f（2）为数字2在数组位置中，在2前面比2小的数，.........，直到f（8），将f（1）+f（2）.....到f(8)的值相加，

　　如果得到的数是偶数则有解，奇数则无解。

　　然后，将每个状态的九宫格替换成一个整数表示，例如样例 123046758，x替换成0，然后用map，来存储状态是否被　　　　　访问过，这样只需遍历0所在位置可以移动的方向，如果没有出界的话，求出移动后的九宫格状态，压入队列中，直到目标解，返回最少步数。具体实现请看代码。

ac代码：

 

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<queue>
#include<map>
#define inf 0x3f3f3f3f
using namespace std;
const int N = 10000 + 10;
int dx[] = { 1,-1,0,0 };
int dy[] = { 0,0,1,-1 };

int a[5][5], d[10];
map<int, int>vis;  //存储九宫格状态是否被访问过
map<int, int>step; //存储到达此状态所需的最少步数
int px, py, lx, ly;

bool check(int u, int v) {        //将九宫格换成二维数组形式，并检查移动后是否出界
    int r = u, x, y;
    for (int i = 3; i >= 1; i--) {
        for (int j = 3; j >= 1; j--) {
            a[i][j] = r % 10;
            r /= 10;
            if (a[i][j] == 0) {
                lx = i, ly = j;
                px = i + dx[v], py = j + dy[v];
                //cout << x << " " << y;
            }
            //cout << a[i][j] << " ";
        }
        //cout << "\n";
    }
    //cout << "\n";
    
    if (px >= 1 && px <= 3 && py >= 1 && py <= 3) {
        return true;
    }
    else return false;
}

int move_to(int ax, int ay, int bx, int by) {   //求解移动后的九宫格状态
    //cout << "...";
    a[ax][ay] = a[bx][by];
    a[bx][by] = 0;
    int val = 0;
    for (int i = 1; i <= 3; i++) {
        for (int j = 1; j <= 3; j++) {
            val = val * 10 + a[i][j];
        }
    }
    return val;
}

int bfs(int k) {        //bfs求最少步数
    queue<int>q;
    q.push(k);
    vis[k] = 1;
    step[k] = 0;
    while (!q.empty()) {
        int t = q.front();
        //cout << t << "\n";
        q.pop();
        int r = t, x = 0, y = 0;
        if (t == 123456780) {    //如果到达返回最少步数
            return step[t];
        }
        for (int i = 0; i < 4; i++) {
            //int px = x + dx[i];
            //int py = y + dy[i];
            //cout << px << " " << py << "\n";
            //cout << "...";
            if (check(t, i)) {
                int pos_now = move_to(lx, ly, px, py);
                //cout << pos_now << "ppp" << "\n";
                if (!vis[pos_now]) {
                    /*for (int i = 1; i <= 3; i++) {
                        for (int j = 1; j <= 3; j++) {
                            cout << a[i][j] << " ";
                        }
                        cout << "\n";
                    }*/
                    //cout << "\n";
                    vis[pos_now] = 1;
                    step[pos_now] = step[t] + 1;
                    q.push(pos_now);
                }
            }
        }
    }
    return 0;
}

int main() {

    int x = 0, cut = 1;
    for (int i = 1; i <= 3; i++) {
        for (int j = 1; j <= 3; j++) {
            char ch;
            cin >> ch;
            if (ch == 'x') ch = '0';
            a[i][j] = ch - '0';
            x = x * 10 + a[i][j];
            d[cut++] = a[i][j];
            //cout << a[i][j] << "\n";
        }
    }
    //求九宫格是否有解
    int rem = 0;
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j < i; j++) {
            if (d[j] == 0) continue;
            if (d[i] > d[j]) rem++;
        }
    }
    //cout << x << "\n";
    if (rem % 2) {
        cout << -1 << "\n";
    }
    else {
        int ans = bfs(x);
        if (ans) cout << ans << "\n";
    }
    
    return 0;
}