AcWing 174. 推箱子(超级麻烦，bfs套bfs)一起来膜拜大佬

题目描述

推箱子游戏相信大家都不陌生，在本题中，你将控制一个人把1个箱子到目的地。
给定一张N行M列的地图，用字符”.”表示空地，字符”#”表示墙，字符”S”表示人的起始位置，字符”B”表示箱子的起始位置，字符”T”表示箱子的目标位置。
求一种移动方案，使箱子移动的次数最少，在此基础上再让人移动的总步数最少。
方案中使用大写的“EWSN”（东西南北）表示箱子的移动，使用小写的“ewsn”（东西南北）表示人的移动。

输入格式
输入包含多个测试用例。
对于每个测试用例，第一行包括两个整数N，M。
接下来N行，每行包括M个字符，用以描绘整个N行M列的地图。
当样例为N=0，M=0时，表示输入终止，且该样例无需处理。
输出格式
对于每个测试用例，第一行输出”Maze #”+测试用例的序号。
第二行输入一个字符串，表示推箱子的总体移动过程，若无解，则输出”Impossible.”。
每个测试用例输出结束后输出一个空行。
若有多条路线满足题目要求，则按照N、S、W、E的顺序优先选择箱子的移动方向（即先上下推，再左右推）。
在此前提下，再按照n、s、w、e的顺序优先选择人的移动方向（即先上下动，再左右动）。
数据范围
1≤N,M≤20
输入样例：
1 7
SB…T
1 7
SB…#.T
7 11
###########
#T##…#
#.#.#…####
#…B…#
#.######…#
#…S…#
###########
8 4
…
.##.
.#…
.#…
.#.B
.##S
…
###T
0 0
输出样例：
Maze #1
EEEEE
Maze #2
Impossible.
Maze #3
eennwwWWWWeeeeeesswwwwwwwnNN
Maze #4
swwwnnnnnneeesssSSS

AcWing 垫底抽风大佬的题解 https://www.acwing.com/user/myspace/index/30334/

分析题目中的四个要求：
箱子移动次数最少
在保证 1 的前提下，人的移动次数最少
在保证 1, 2 的前提下，箱子按照 N、S、W、E 的顺序优先选择移动方向
在保证 1, 2, 3 的前提下，人按照 n、s、w、e 的顺序优先选择移动方向
状态表示：
考虑把 人的坐标人的坐标 和 箱子的坐标箱子的坐标 整体看做一个状态
那么可以保证 人的移动次数+箱子的移动次数人的移动次数+箱子的移动次数 最小，无法保证箱子的移动次数最小，所以不可取。
我们可以先假设我们可以任意的推箱子，而不考虑人怎么动。这样就可以保证箱子的移动次数最少。
那么我们就可以直接 bfs 求最短路。
然后对于我们所推的每一步，再对人做一遍 bfs，求出人到我们所推的位置即可。
举个例子：
如果我们宽搜时，箱子的下一步是往左走，那么我们就要同时 bfs 求出人到箱子右边的最短路。
但是我们在宽搜的时候，不能保证人一定能到我们所推的地方。
举个例子：
对于这张图，如果我们要把箱子向右推那么人就必须要走到箱子的左边，但是人并不能走到箱子的左边。
所以我们在宽搜的时候，对于箱子，我们不仅要记录它的坐标位置，还要记录它是从哪个方向推过来的。
然后就不难写出 bfs 了。
这里说下要注意的两点
对方向的加减
四个方向的枚举顺序
时间复杂度
最坏情况下，箱子会跑满地图，移动次数是 nmnm，
每次移动箱子，人都要响应的跑一遍 bfsbfs，最多移动 nmnm 次，
所以总的时间复杂度貌似是 O((nm)2)O((nm)2)
（这个不是很确定，若有错误，还请大佬指正~）

#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>

using namespace std;

typedef pair<int, int> pii;
const int N = 25;
const int dx[4] = {1, -1, 0, 0}; // 存 人 对于 箱子 的四个位置的偏移量
const int dy[4] = {0, 0, 1, -1};
const char ops[5] = "nswe";      // 按题目要求的字典序存四个方向对应的字符

struct Point  // 存每个位置的状态。由于要存过来的方向，所以用结构体存
{
    int x, y; // 坐标位置
    int dir;  // 从哪边来的
};
int n, m;     // 地图长宽
char g[N][N]; // 存地图
pii dist[N][N][4];  // 存到每个状态的最短距离。first 存箱子的移动距离，second 存人的移动距离
Point pre[N][N][4]; // 存箱子是从哪个状态转移过来的
vector<int> path[N][N][4];   // 存到每个状态的路径
bool st[N][N][4], vis[N][N]; // 对箱子做 bfs 时用 st 判重，对人做 bfs 时用 vis 判重
int pre_man[N][N];  // 存人是从哪个状态转移过来的

bool check(int x, int y) // 判断 (x, y) 这个格子是否可以走
{
    return ~x && ~y && x < n && y < m && g[x][y] != '#';
}

// 对人做 bfs。判断人是否能从 start 走到 end 且不经过 box
// 如果能，将路径存入 seq 中，并返回路径长度；如果不能，则返回 -1
int bfs_man(pii start, pii end, pii box, vector<int> &seq)
{
    memset(vis, false, sizeof vis);        // 将 vis 初始化成 0
    memset(pre_man, -1, sizeof pre_man);   // 将 pre_man 初始化成 -1
    vis[start.first][start.second] = true; // start 的位置不能走
    vis[box.first][box.second] = true;     // box 的位置不能走
    queue<pii> q; q.push(start);           // 将 start 加入队列
    while (q.size())
    {
        pii t = q.front();
        q.pop();
        int x = t.first, y = t.second;
        if (t == end) // 如果人到终点了
        {
            seq.clear(); // 先将 seq 清空
            while (~pre_man[x][y]) // 然后反向往前求出走的路径
            {
                int dir = pre_man[x][y];    // 取出到 (x, y) 时，所走的方向
                seq.push_back(dir);         // 将该方向加入 seq
                x += dx[dir], y += dy[dir]; // x 和 y 按该方向相反的方向走回去
            }
            return seq.size();     // 最后返回路径的长度
        }
        for (int i = 0; i < 4; i ++ )
        {
            // 由于 dx 和 dy 存的是人对于箱子的方向，和所要走的四个方向是反着的
            // 直接用 + dx[i] 和 + dy[i] 也能遍历四个方向，但是无法保证字典序最小
            // 所以这里要反过来，用 - dx[i] 和 - dy[i]
            int a = x - dx[i], b = y - dy[i];
            if (!check(a, b) || vis[a][b]) continue; // 如果 (a, b) 不能走，直接跳过
            vis[a][b] = true;  // 记录 (a, b) 已经被走过了
            pre_man[a][b] = i; // 记录到 (a, b) 的方向为 i
            q.push({a, b});    // 将 (a, b) 加入队列
        }
    }
    return -1; // 如果无法到达 end，那么返回 -1
}

// 对箱子做 bfs，并返回是否能到达终点
bool bfs_box(pii start, pii box, Point &end)
{
    memset(st, false, sizeof st); // 将 st 初始化为 false
    queue<Point> q;
    // 枚举四个相邻的位置，如果能从 box 到达该位置，那么将该位置加入队列
    for (int i = 0; i < 4; i ++ )
    {
        int a = box.first + dx[i], b = box.second + dy[i]; // 人要走到的位置
        int c = box.first - dx[i], d = box.second - dy[i]; // 箱子推到的位置
        if (!check(a, b) || !check(c, d)) continue; // 如果 (a, b) 或 (c, d) 不能走，直接跳过
        vector<int> seq;          // 对人做一遍 bfs
        // 传参含义：从 start 到 (a, b) 且不经过 box，将路径存入 seq 中
        int len = bfs_man(start, {a, b}, box, seq);
        if (len == -1) continue;  // 如果返回值为 -1，说明不能走到，直接跳过
        q.push({c, d, i});        // 否则能到，将该点加入队列中
        st[c][d][i] = true;       // 标记该点被经历过
        path[c][d][i] = seq;      // 到该点的路径为 seq
        dist[c][d][i] = {1, len}; // 到该点的距离为：箱子被推了 1 步，人走了 len 步
        // 记录该点是从 (box.first, box.second) 到达的，为了方便最后处理答案，将方向制为 -1
        pre[c][d][i] = {box.first, box.second, -1};
    }
    pii maxd = {1e9, 1e9};   // 存到终点的最短距离，先初始化成一个巨大的数
    while (q.size())
    {
        Point t = q.front(); // 取出队头
        q.pop();
        pii &v = dist[t.x][t.y][t.dir]; // 取出到队头状态的距离 
        // 如果到达了终点，并且距离比 maxd 更小，那么更新 maxd 并标记 end
        if (g[t.x][t.y] == 'T' && v < maxd)
        {
            end = t;
            maxd = v;
        }
        for (int i = 0; i < 4; i ++ )
        {
            int a = t.x + dx[i], b = t.y + dy[i]; // 人要走到的位置
            int c = t.x - dx[i], d = t.y - dy[i]; // 箱子推到的位置
            if (!check(a, b) || !check(c, d)) continue; // 如果 (a, b) 或 (c, d) 不能走，直接跳过
            vector<int> seq;
            // 箱子是从 t.dir 的方向被推过来的，所以推之前的位置就是 (t.x + dx[t.dir], t.y + dy[t.dir])
            // 所以推完之后，人就应该在箱子原来的位置，也就是 (t.x + dx[t.dir], t.y + dy[t.dir])
            int len = bfs_man({t.x + dx[t.dir], t.y + dy[t.dir]}, {a, b}, {t.x, t.y}, seq);
            if (len == -1) continue; // 如果返回值为 -1，说明人到不了 (a, b)，直接跳过
            pii distance = {v.first + 1, v.second + len}; // 否则能到，求出到这个状态的距离
            if (!st[c][d][i])        // 如果 {c, d, i} 这个状态没被到过
            {
                q.push({c, d, i});   // 该状态入队
                st[c][d][i] = true;  // 标记这个状态被到过
                path[c][d][i] = seq; // 到该状态的路径为 seq
                dist[c][d][i] = distance; // 到该状态的距离为 distance
                pre[c][d][i] = t;    // 该状态是由 t 到达的
            }
            else if (dist[c][d][i] > distance) // 否则如果这次到达 {c, d, i} 的路径更近
            {
                dist[c][d][i] = distance; // 更新到达该状态的距离
                path[c][d][i] = seq;      // 将到达该状态的路径改为 seq
                pre[c][d][i] = t;         // 将该状态改为由 t 到达的
            }
        }
    }
    return maxd.first != 1e9; // 如果 maxd.first != 1e9 ，说明 maxd 被更新过，也就是能到达 end
}

int main()
{
    for (int T = 0; scanf("%d%d", &n, &m), n || m;)
    {
        printf("Maze #%d\n", ++ T); // 先输出这是第几组数据
        for (int i = 0; i < n; i ++ ) scanf("%s", g[i]); // 读入地图
        pii start, box;             // 找到人的位置和箱子的位置，分别存入 start 和 box 中
        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < m; j ++ )
                if (g[i][j] == 'S') start = make_pair(i, j);
                else if (g[i][j] == 'B') box = make_pair(i, j);
        Point end; string res;      // end 存终点的位置，在 bfs 时记录即可。res 存答案
        if (!bfs_box(start, box, end)) res = "Impossible."; // 如果到不了终点，要输出 Impossible.
        else // 否则要找出到达终点的路径
        {
            while (~end.dir) // 被起点到达的状态的 dir 被标记成了 -1
            {
                res += ops[end.dir] - 32; // 存箱子移动的路径。小写字母 -32 变成大写字母
                for (int i = 0; i < path[end.x][end.y][end.dir].size(); i ++ )
                    res += ops[path[end.x][end.y][end.dir][i]]; // 存人移动的路径
                end = pre[end.x][end.y][end.dir]; // end 往前倒着找
            }
            reverse(res.begin(), res.end());      // 由于记录的序列是倒着的，最后要反转下再输出
        }
        cout << res << endl << endl;              // 输出答案
    }
    return 0;
}

作者：垫底抽风
链接：https://www.acwing.com/solution/content/16343/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。