41.Acwing基础课第845题-中等-八数码

41.Acwing基础课第845题-中等-八数码

题目描述

在一个 3×3 的网格中，1∼8 这 8 个数字和一个 x 恰好不重不漏地分布在这 3×3 的网格中。

例如：

1 2 3
x 4 6
7 5 8

在游戏过程中，可以把 x 与其上、下、左、右四个方向之一的数字交换（如果存在）。

我们的目的是通过交换，使得网格变为如下排列（称为正确排列）：

1 2 3
4 5 6
7 8 x

例如，示例中图形就可以通过让 x 先后与右、下、右三个方向的数字交换成功得到正确排列。

交换过程如下：

1 2 3   1 2 3   1 2 3   1 2 3
x 4 6   4 x 6   4 5 6   4 5 6
7 5 8   7 5 8   7 x 8   7 8 x

现在，给你一个初始网格，请你求出得到正确排列至少需要进行多少次交换。

输入格式

输入占一行，将 3×3 的初始网格描绘出来。

例如，如果初始网格如下所示：

1 2 3 
x 4 6 
7 5 8 

则输入为：1 2 3 x 4 6 7 5 8

输出格式

输出占一行，包含一个整数，表示最少交换次数。

如果不存在解决方案，则输出 −1。

输入样例：

2 3 4 1 5 x 7 6 8

输出样例：

19

代码：

#include <iostream>
#include <algorithm>   // 用于 swap 交换
#include <unordered_map> // 哈希表，记录每个状态走了多少步
#include <queue>       // BFS 队列
using namespace std;

// BFS 函数：输入初始状态字符串，返回最小步数，无解返回 -1
int bfs(string state)
{
    queue<string> q;          // BFS 队列：存储每一种棋盘状态
    unordered_map<string, int> d;  // 哈希表：key=棋盘状态，value=走到这里的步数

    q.push(state);            // 把初始状态加入队列
    d[state] = 0;             // 初始状态的步数为 0

    // 四个方向：上、右、下、左
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

    string end = "12345678x";  // 目标状态

    // BFS 循环：队列不为空就继续
    while (q.size())
    {
        auto t = q.front();    // 取出队头状态
        q.pop();               // 弹出队头

        // 如果当前状态 == 目标状态，直接返回步数
        if (t == end) return d[t];

        int distance = d[t];   // 当前状态的步数
        int k = t.find('x');   // 找到字符 'x' 在字符串中的位置下标
        int x = k / 3;         // 把一维下标转成二维坐标：行
        int y = k % 3;         // 列

        // 枚举 x 的四个方向
        for (int i = 0; i < 4; i ++ )
        {
            int a = x + dx[i];    // 新的行
            int b = y + dy[i];    // 新的列

            // 判断新坐标是否在 3x3 棋盘内
            if (a >= 0 && a < 3 && b >= 0 && b < 3)
            {
                // 交换 x 和 相邻数字，得到新状态
                swap(t[a * 3 + b], t[k]);

                // 如果这个新状态没走过
                if (!d.count(t))
                {
                    d[t] = distance + 1;  // 步数 = 当前 + 1
                    q.push(t);            // 新状态入队
                }

                swap(t[a * 3 + b], t[k]); // 恢复状态（回溯）
            }
        }
    }

    return -1;  // 队列空了都没找到，无解
}

int main()
{
    char s[2];         // 临时存输入的单个字符

    string state;      // 存储初始棋盘状态（变成字符串）
    for (int i = 0; i < 9; i ++ )
    {
        cin >> s;      // 输入 9 个字符（1~8 + x）
        state += *s;   // 拼成一个长字符串
    }

    cout << bfs(state) << endl;  // 输出最小步数

    return 0;
}