【HDU-1043】Eight 八数码（BFS之A*算法）

BraumAce

已于 2023-08-02 13:59:37 修改

阅读量513

点赞数 1

分类专栏： # 搜索数据结构与算法文章标签：算法宽度优先 c++ A-star算法搜索

于 2023-08-02 13:48:25 首次发布

本文链接：https://blog.csdn.net/qq_59904473/article/details/132060264

版权

数据结构与算法同时被 2 个专栏收录

22 篇文章 0 订阅

订阅专栏

搜索

5 篇文章 0 订阅

订阅专栏

Eight（八数码）

Vjudge链接

题目描述

15 块拼图已有 100 多年的历史，即使你不知道它的名字，也一定见过它。它由 15 块滑动瓷砖组成，每块瓷砖上都有一个从 1 到 15 的数字，所有瓷砖都被装在一个 4×4 的框架内，其中缺少一块瓷砖。我们把这块缺失的瓷砖称为 “x”；谜题的目的是将瓷砖排列成以下顺序：

 1  2  3  4
 5  6  7  8
 9 10 11 12
13 14 15  x

其中唯一合法的操作是将 "x "与与它共享一条边的其中一块牌交换。举例来说，下面的移动顺序可以解决一个略微混乱的谜题：

 1  2  3  4     1  2  3  4     1  2  3  4     1  2  3  4
 5  6  7  8     5  6  7  8     5  6  7  8     5  6  7  8
 9  x 10 12     9 10  x 12     9 10 11 12     9 10 11 12
13 14 11 15    13 14 11 15    13 14  x 15    13 14 15  x
            r->            d->            r->

上一行中的字母表示每一步中 "x "与 "x "的哪一个相邻棋子进行了交换；合法值分别为 “r”、“l”、"u "和 “d”，代表右、左、上和下。

并不是所有的谜题都能被解开；1870 年，一个名叫山姆-洛伊德的人因为分发了一个无法解开的谜题版本而出名，让很多人感到沮丧。
让很多人感到沮丧。事实上，要把一道普通的谜题变成一道无解的谜题，只需要交换两块牌（当然，缺失的 "x "牌不算在内）。

在这个问题中，你将编写一个程序来解决不太为人所知的 8 字谜排列。

输入：

您将收到几种关于 "8 "字谜题配置的说明。其中一种描述仅仅是一张牌子初始位置的列表，行列从上到下依次排列，每一行中的牌子从左到右依次排列，牌子用数字1到8加上 "x "来表示。例如，这道谜题

1 2 3
x 4 6
7 5 8

就是用这个列表来描述的：

1 2 3 x 4 6 7 5 8

输出：

如果谜题无解，您将在标准输出中打印 “unsolvable”（无解）字样，或者打印一个完全由字母 “r”、“l”、"u "和 "d "组成的字符串，描述一系列产生解的棋步。字符串不得包含空格，并从行首开始。不要在每种情况之间打印空行。

输入样例：

2  3  4  1  5  x  7  6  8

输出样例：

ullddrurdllurdruldr

题意

给定一个九方格，每个方格都有一个数字，分别是 $1 \sim 8$ 和一个 x ，规定可以把 x 与其上、下、左、右四个方向之一的数字进行交换（如果存在）。要求我们通过交换，使得网格变为如下排列：

1 2 3
4 5 6
7 8 x

不过，题目是以字符串的形式给出初始状态，也就是说，我们最终需要达到

1 2 3 4 5 6 7 8 x

的状态，如果可以则输出每一步的操作步骤，否则输出 “unsolvable”。

思路

这里使用 A* 算法解决，相关学习可转至：Introduction to the A* Algorithm

首先要知道八数码有解的条件，可参考：八数码问题有解的条件及其推广

将八数码原本的二维形式转化为一维形式，求出所有的逆序对，当逆序对的数量为偶数时，有解，否则无解。

设估价函数 f() 为当前点的状态与目标状态的曼哈顿距离之和，

因为 A* 算法要求 当前状态的真实距离 + 到终点的估计距离 <= 起点到终点的真实距离 ，所以我们可以用优先队列存储每次的状态，保证终点在第一次出队时即为最优解。同时用 prev 记录每次的操作和上一步状态，方便最后回推输出操作路径。

详细见代码↓

代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <unordered_map>
#define PIS pair<int, string>

using namespace std;

int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, 1, 0, -1};
char op[5] = "urdl";

// 从该状态到达目标状态的估价函数
// 计算各个点与目标状态的曼哈顿距离之和
int f(string state)
{
    int res = 0;
    for (int i = 0; i < state.size(); i++){
        if (state[i] != 'x')
        {
            int t = state[i] - '1';
            res += abs(i / 3 - t / 3) + abs(i % 3 - t % 3);
        }
    }
    
    return res;
}

string bfs(string start)
{
    string end = "12345678x";
    unordered_map<string, int> dist;
    unordered_map<string, pair<string, char>> prev; // 记录到达此状态的操作和上一步状态
    // 初始化小根堆
    // 第一元素：从起点到该状态的真实距离+该状态到目标状态的估价距离
    // 第二元素：存储该状态
    priority_queue<PIS, vector<PIS>, greater<PIS>> heap;
    
    heap.push({f(start), start});
    dist[start] = 0;
    
    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();
        
        string state = t.second;
        if (state == end) break;
        
        // 求'x'的坐标
        int x, y;
        for (int i = 0; i < state.size(); i++){
            if (state[i] == 'x'){
                x = i / 3, y = i % 3;
                break;
            }
        }
        
        int step = dist[state];  // 记录原来到达该状态的距离
        string source = state;   // 存储备份该状态
        for (int i = 0; i < 4; i++){
            int xx = x + dx[i], yy = y + dy[i];
            if (xx >= 0 && xx < 3 && yy >= 0 && yy < 3){
                swap(state[x * 3 + y], state[xx * 3 + yy]);  // 交换
                if (!dist.count(state) || dist[state] > step + 1)
                {
                    dist[state] = step + 1;
                    prev[state] = {source, op[i]};
                    heap.push({dist[state] + f(state), state});
                }
                swap(state[x * 3 + y], state[xx * 3 + yy]);  // 恢复
            }
        }
    }
    
    // 回推路径
    string res;
    while (end != start)
    {
        res += prev[end].second;
        end = prev[end].first;
    }
    
    reverse(res.begin(), res.end());
    
    return res;
}

int main()
{
    string g, c, seq;
    while (cin >> c)
    {
        g += c;
        if (c != "x") seq += c;
    }
    
    // 记录逆序对的对数
    // 如果逆序对的数量是偶数，那就一定有解
    int cnt = 0;  
    for (int i = 0; i < seq.size(); i++){
        for (int j = i + 1; j < seq.size(); j++){
            if (seq[i] > seq[j])
                cnt++;
        }
    }
    
    if (cnt % 2) puts("unsolvable");
    else cout << bfs(g) << endl;
    
    return 0;
}