八数码问题

题目：

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


思路：

首先求最小的交换次数，就用bfs

题目类似于数字华容道，可以抽象一下，把每一个状态当成一个节点a，它的变化后的下一个状态是另一个节点假如是b，我们就连一条a到b的边，权重是1，例如，

1 2 3                        1 2 3  
x 4 6     变化到         4 x 6       可以看成一个节点到另一个节点的变化，
7 5 8                         7 5 8 

所以有两个问题
1.状态表示复杂：

宽搜里面要定义一个queue，这个队列要怎么定义

2.如何记录每个状态的距离

3.状态转移

解决方案：

状态表示：我们可以把二维三乘三的矩阵变成一维的string来存储，用一个字符串来表示一个状态，队列定义的话直接queue<string>q;就行了
距离数组我们可以用哈希表，unordered_map<sting, int> d;表示
状态转移，我们先把字符串想象成三乘三的样子，把x的上下左右分别枚举，把这些位置的数移动到x上，最后再把它变成string

#include<iostream>
#include<algorithm>
#include<queue>
#include<unordered_map>

using namespace std;

queue<string> q; // 定义队列
string s; // 初始的状态
unordered_map<string, int> d; // 表示节点的距离

int bfs(string s)
{
    string end = "12345678x"; // 终点
    
    d[s] = 0; // 将字符串理解成一个节点，初始状态就是起点，起点到起点的距离是0
    q.push(s); // 将起点放入队列
    
    int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1}; // 定义四个方向的向量数组
    
    while (!q.empty()) // 框架
    {
        auto t = q.front(); // 取出队头
        q.pop(); // 弹出队头
        
        if (t == end) return d[t]; // 如果是终点了，输出
        
        int distance = d[t]; // 存储队头的距离，因为下面要计算状态转移后的距离，状态会变化，要先存下变化前的距离
        int k = t.find('x'); // 找出x在字符串中的下标，后面计算在矩阵里的xy值要用
        int x = k / 3, y = k % 3; // 计算x在三乘三矩阵中的坐标位置
        
        for (int i = 0; i < 4; i ++ ) // 遍历四个方向
        {
            int a = x + dx[i], b = y + dy[i]; // 变化后的坐标位置
            
            if (a >= 0 && a < 3 && b >= 0 && b < 3) // 是否出界
            {  // 状态转移
                swap(t[a * 3 + b], t[k]); // 没有出界的话就把数移到x位置上，交换x和数，
                
                if (!d.count(t)) // 可以看stl里面count的作用，看是否之前出现过这个状态，看成节点的意思就是，看这个点是否遍历过
                {
                    d[t] = distance + 1; // 如果是新的点（字符串），计算出距离
                    q.push(t); // 将其放入队列
                }
                
                swap(t[a * 3 + b], t[k]); // 记得恢复，因为要遍历四个方向
            }
        }
    }
    
    return -1; // 如果while循环完了还没有最终的结果，那就是不存在解决方案
}

int main()
{
    for (int i = 0; i < 9; i ++ ) // 输入初始状态
    {
        char c;
        cin >> c;
        s += c;
    }
    
    cout << bfs(s) << endl;
    
    return 0;
}