[A*] aw179. 八数码(A*+bfs最小步数模型+模板题)

1. 题目来源

链接：179. 八数码

相关：

• [bfs+图论] aw845. 八数码(建图+bfs最小步数模型+思维)
• [bfs] aw1107. 魔板(bfs最小步数模型+代码细节+代码功底+好题)

2. 题目解析

关于 $A^{\ast }$ 算法的证明本人蒟蒻就不谈了，只总结分享下它的适用场景和主要用途：

• 适用于状态量很大的最小步数模型，一般状态量为指数级别。 在本题的 8 数码、15 数码中有非常优异的表现，且在迷宫问题上表现也十分优秀！
• $A^{\ast }$ 算法在代码结构上和堆优化 dijkstra() 算法相似，但在算法本质中两者并无关系。
• 同理，需要使用小根堆，在此用优先队列实现。堆中维护 {dist, state}，其中 dist 由起点到该点的真实距离+该点到终点的估价距离 两部分组成。
• 最重要的就是 $A^{\ast }$ 算法中的估价距离的定义与设计，每个中间点到终点的估价距离必须小于等于真实距离。
• 显然，估价距离可以取 0 一定满足要求，但是此时 $A\ast$ 算法将和堆优化 dijkstra() 相同，体现不出算法优势，搜索到的解空间仍然十分庞大。
• 当估价距离取值越接近真实距离时，算法效率越高，可行解空间很小。
• $A^{\ast }$ 算法仅能保证终点在出优先队列时它的最小步数、最短路。其它各点均无法保证。 因为它的边权不唯一且会进行重复入队这一操作，所以无法以点入队作为更新条件，无法以出队作为更新条件，终点是个例外，终点在第一次出队时一定为答案，为最小步数。
• $A^{\ast }$ 算法不要处理有负权边的问题。
• $A^{\ast }$ 算法最好处理一定有解的问题，若问题无解，仍会搜完全部解空间，且在此使用的优先队列，会比朴素 bfs 还要慢一个 $logn$。

---

八数码问题有解情况的充要条件：将二维棋盘数组按行写为一行，若逆序对个数为偶数则有解，否则无解。

• 充分性证明：过于难证，略过。
• 必要性证明：
  • 若空格在行内移动：不影响逆序对的数量，奇偶性不发生改变。
  • 若空格在列内移动：等价于在一行中，将该位置数向前移动两个位置、向后移动两个位置，逆序对只会有三种改变 -2，0，+2，奇偶性也不发生改变。
  • 则，最终状态逆序对为 0，若初始状态逆序对个数为奇数，则一定无解。

---

很优秀就完事了

时间复杂度：$O()

空间复杂度：$O()$

---

// 启发式算法，A*，估价函数为点到对应位置的曼哈顿距离
// 整体代码框架类比堆优化dijkstra()，但两者本质没有任何关系
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <string>

using namespace std;

typedef pair<int, string> PIS;

// 计算每个状态到终点的估值，估价函数设定为每个点到对应位置的曼哈顿距离
int f(string s) {
    int res = 0;
    for (int i = 0; i < s.size(); i ++ ) {
        if (s[i] != 'x') {
            int t = s[i] - '1';     // 从 0 开始，映射到 3*3 方格中求曼哈顿距离
            res += abs(i / 3 - t / 3) + abs(i % 3 - t % 3);
        }
    }

    return res;
}

string bfs(string start, string end) {
    unordered_map<string, int> dist;
    unordered_map<string, pair<char, string>> prev;
    priority_queue<PIS, vector<PIS>, greater<PIS>> heap;

    dist[start] = 0;
    heap.push({f(start), start});

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

    // 类比堆优化dijkstra()
    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 < 9; i ++ )
            if (state[i] == 'x') {
                x = i / 3, y = i % 3;
                break;
            }

        // 四方向扩展
        string backup = state;
        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) continue;
            state = backup;             // 不要忘记恢复原状
            swap(state[a * 3 + b], state[x * 3 + y]);
            
            /*
			A*算法，除了终点之外，当第一次搜到某个点的时候，距离不一定是最短的，
			其dist[]的值是不断变小的，所以要加后一个判断。
			*/
            // 新状态未被扩展，或者新状态距离更小，均需要更新这个新状态
            if (dist.count(state) == 0 || dist[state] > dist[backup] + 1) {
                dist[state] = dist[backup] + 1;
                prev[state] = {op[i], backup};
                heap.push({dist[state] + f(state), state});
            }
        }
    }

    // 可能存在多种方案，所以输出答案可能与样例输出不符
    string res;
    while (end != start) {
        res += prev[end].first;
        end = prev[end].second;
    }
    reverse(res.begin(), res.end());

    return res;
}

int main() {
    string start, end, seq;
    char c;
    while (cin >> c) {
        start += c;
        if (c != 'x') seq += c;
    }

    end = "12345678x";

    // 无解情况判断，判断逆序对个数，偶数有解，奇数无解
    int cnt = 0;
    for (int i = 0; i < 8; i ++ ) 
        for (int j = 0; j < i; j ++ ) 
            if (seq[i] < seq[j])
                cnt ++ ;

    if (cnt & 1) puts("unsolvable");
    else cout << bfs(start, end) << endl;

    return 0;
}