八数码问题的几种解法

八数码问题

注：本实验我采用的都是从283104765到123804765的最短步数

1. 用双向BFS解决八数码问题

        首先，双向bfs指的是从初始状态和目标状态同时开始搜索,广度优先搜索是每次先搜索周围，然后再向外扩展，（这里我们把矩阵转化为数字序列，更方便）我将用一个队列先把初始序列和目标序列依次放入队列q，分别为第一个和第二个,然后根据bfs的先进先出的特性，将会按顺序一层一层的搜索,当从初始序列开始后，会移动空格（这里用0表示）并交换位置，然后把交换位置,之后的序列依次入队，初始状态序列bfs完后，就轮到第二个目标状态序列了，同样会产生交换位置之后的序列，这样的话就可以实现从初始状态和目标状态两头同时进行bfs搜索，会大大加快速度，终止条件就是当两头出现相交时，为结束。

//双向BFS，从起点和终点两个方向开始搜索，
//如果某一个状态下出现相交的情况，那么就出现了答案
#include <iostream>
#include <bits/stdc++.h>

#define ll long long int
using namespace std;

//这里我们把矩阵转化为数字序列，更方便
int start, target = 123804765;    //start表示开始序列，target表示目标序列
int a[4][4], fx, fy, nx, ny;
int dx[4] = {1, -1, 0, 0};    //代表四个移动方向
int dy[4] = {0, 0, 1, -1};
queue<int> q;
map<int, int> ans;                //ans用来记录步数
map<int, int> v;                //v用来记录状态，是否顺序和逆序访问过

void solve() {
    if (start == target) {   //特例，直接输出0（就是初始状态一来就等于目标状态）
        cout << "最短步数为：0" << endl;
        return;
    }
    q.push(start);        //起始状态和终止状态依次入队
    q.push(target);
    ans[start] = 0;        //ans记录步数
    ans[target] = 1;
    v[start] = 1;        //状态1表示顺序访问过，即从起点开始搜索
    v[target] = 2;        //状态2表示逆序访问过，即从终点开始搜索
    while (!q.empty()) {    //从这里开始bfs，根据队列先进先出的特性
        ll now, cur = q.front();   //cur用来放移动前的序列，now用来放移动后的序列
        q.pop();            //把用完的序列从队列中弹出
        now = cur;
        for (int i = 3; i >= 1; i--) {            //把序列转换成矩阵
            for (int j = 3; j >= 1; j--) {
                a[i][j] = now % 10;
                now /= 10;
                if (a[i][j] == 0) {                //找起点0
                    fx = i;
                    fy = j;
                }
            }
        }
        for (int i = 0; i < 4; i++) {            //开始向四周移动
            nx = fx + dx[i];
            ny = fy + dy[i];
            if (nx < 1 || nx > 3 || ny < 1 || ny > 3)    //判断是否出界
                continue;
            swap(a[fx][fy], a[nx][ny]);          //把当前位置和移动之后的位置交换
            now = 0;        //给now清零，好放下一个序列
            for (int p = 1; p <= 3; p++) {        //把移动之后的矩阵转换成序列
                for (int j = 1; j <= 3; j++) {
                    now = now * 10 + a[p][j];
                }
            }
            if (v[now] == v[cur]) {        //如果移动前的序列和移动后的序列是相等的，说明已经存在了
                swap(a[fx][fy], a[nx][ny]); 			//则之前的移动无效，要换回来
                continue;
            }
            if (v[now] + v[cur] == 3) { //即顺序1和逆序2都访问过了，两者标记相加就为3，说明找到了答案
                cout << "最短步数为：" << (ans[cur] + ans[now]) << endl;  //两方向步数和即为总步数
                return;
            }
            ans[now] = ans[cur] + 1;
            v[now] = v[cur];    //与上一状态的方向保持一致
            q.push(now);        //把的移动后的序列入队
            swap(a[fx][fy], a[nx][ny]); // 移动完了之后还要还原
        }
    }
}

int main() {
    cin >> start;
    solve();

    return 0;
}

结果：

2. 用迭代加深搜的A*算法解决八数码问题

        由于迭代加深搜的A算法里面其实包含了深度优先搜索，所以我就不再另外写dfs算法了，其实IDA算法就是广度优先搜索和深度优先搜索和A*算法三者的结合，可以通过自己设置，最大深度maxdep，逐步加大搜索深度来获得最优解，而如果使用dfs搜索策略的话，就需要对整个搜索空间进行搜索，采用估值函数，剪掉f(n)>maxdep的路径，通过剪枝去掉重复的路径，可以大大减小时间复杂度。

#include<bits/stdc++.h>

using namespace std;
int dis[9][9] = {   //当前位置和目标位置间的曼哈顿距离
        {0, 1, 2, 1, 2, 3, 2, 3, 4},    //即从该点到其它8个点需要移动的步数
        {1, 0, 1, 2, 1, 2, 3, 2, 3},
        {2, 1, 0, 3, 2, 1, 4, 3, 2},
        {1, 2, 3, 0, 1, 2, 1, 2, 3},
        {2, 1, 2, 1, 0, 1, 2, 1, 2},
        {3, 2, 1, 2, 1, 0, 3, 2, 1},
        {2, 3, 4, 1, 2, 3, 0, 1, 2},
        {3, 2, 3, 2, 1, 2, 1, 0, 1},
        {4, 3, 2, 3, 2, 1, 2, 1, 0}
};
int yuan[9] = {4, 0, 1, 2, 5, 8, 7, 6, 3};      //每个数字的目标状态的位置
int chu[3][3];  //存储当前状态
char k;
int sx, sy;
int ax[4] = {0, -1, 1, 0};
int ay[4] = {1, 0, 0, -1}; //这两个数组一定要对称写，使搜索时不会返回上一状态
bool flag;

int h() {
    int ans = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++) {
            if (chu[i][j] == 0) continue;   //不考虑0
            ans += dis[yuan[chu[i][j]]][i * 3 + j]; //i*3+j表示数字现在位置
        }
    return ans;
}

void dfs(int ceng, int dep, int f, int x, int y) { //f表示上一次转移的方向
    int nx, ny;
    if (ceng == dep) {  //如果搜到了预期层数
        if (!h()) flag = 1; //如果达到了目标状态
        return;
    }
    for (int i = 0; i < 4; i++) {
        nx = x + ax[i];
        ny = y + ay[i];

        if (nx < 0 || ny < 0 || nx >= 3 || ny >= 3) continue;//出界
        if (i + f == 3)  continue;//如果会返回上一个状态，就跳过，这个地方为剪枝因为当i+f == 3时，根据移动规律，一定会往回走，也就重复了，所以要舍去这种情况
        swap(chu[nx][ny], chu[x][y]);
        if (ceng + h() <= dep)//如果最优情况都会超出预期，就直接返回
            dfs(ceng + 1, dep, i, nx, ny);
        if (flag) return;//找到解就直接返回
        swap(chu[nx][ny], chu[x][y]);//回溯
    }
}

int main() {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cin >> k;
            chu[i][j] = k - '0';
            if (k == '0') {
                sx = i;
                sy = j;//初始0的位置
            }
        }
    }
    if (!h()) {     //判特，如果一开始就达到目标，直接结束
        cout << "最短路径为：" << 0;
    }
    flag = 0;
    int maxdep;     //预期深度
    for (maxdep = 1;; maxdep++) {   //一层一层地搜
        dfs(0, maxdep, -1, sx, sy); //0表示从0层开始，一开始没有方向，所以传入-1
        if (flag) {     //找到解
            cout << "最短路径为：" << maxdep << endl;
            break;
        }
    }
    return 0;
}

结果：