【ACWing】177. 噩梦

题目地址：

https://www.acwing.com/problem/content/179/

给定一张$N\times M$的地图，地图中有$1$个男孩，$1$个女孩和$2$个鬼。字符$.$表示道路，字符$X$表示墙，字符$M$表示男孩的位置，字符$G$表示女孩的位置，字符$Z$表示鬼的位置。男孩每秒可以移动$3$个单位距离，女孩每秒可以移动$1$个单位距离，男孩和女孩只能朝上下左右四个方向移动。每个鬼占据的区域每秒可以向四周扩张$2$个单位距离，并且无视墙的阻挡，也就是在第$k$秒后所有与鬼的曼哈顿距离不超过$2k$的位置都会被鬼占领。注意：每一秒鬼会先扩展，扩展完毕后男孩和女孩才可以移动。求在不进入鬼的占领区的前提下，男孩和女孩能否会合，若能会合，求出最短会合时间。

输入格式：
第一行包含整数$T$，表示共有$T$组测试用例。每组测试用例第一行包含两个整数$N$和$M$，表示地图的尺寸。接下来$N$行每行$M$个字符，用来描绘整张地图的状况。（注意：地图中一定有且仅有$1$个男孩，$1$个女孩和$2$个鬼）

输出格式：
每个测试用例输出一个整数$S$，表示最短会合时间。如果无法会合则输出$-1$。每个结果占一行。

数据范围：
$1<n,m<800$

思路是从男生和女生两个方向同时做BFS，即双向BFS。对男生，在扩展的时候，先看扩展的点是否被鬼占领，如果是，则说明该位置不能继续扩展（因为此时已经被鬼抓住了）；如果不是，则继续扩展，如果扩展出来的点之前没扩展过、没被鬼占领并且女生能走到，则说明可以会合，否则继续扩展，如此扩展$3$次；对女生也类似，不过只扩展$1$次。如果扩展到最后无法会合，则输出$-1$。代码如下：

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
using PII = pair<int, int>;

const int N = 810;
int n, m, cnt;
char g[N][N];
int vis[N][N];
PII ghost[2], boy, girl;
int d[] = {-1, 0, 1, 0, -1};

bool check(int x, int y, int step) {
    if (x < 0 || x >= n || y < 0 || y >= m || g[x][y] == 'X') return false;
    for (int i = 0; i < 2; i++)
        if (abs(x - ghost[i].first) + abs(y - ghost[i].second) <= step * 2) return false;
    return true;
}

int bfs() {
    cnt = 0;
    memset(vis, 0, sizeof vis);
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if (g[i][j] == 'M') boy = {i, j};
            else if (g[i][j] == 'G') girl = {i, j};
            else if (g[i][j] == 'Z') ghost[cnt++] = {i, j};
    
    int step = 0;
    queue<PII> qb, qg;
    qb.push(boy), qg.push(girl);
    while (qb.size() && qg.size()) {
        step++;
        for (int i = 0; i < 3; i++)
            for (int j = qb.size(); j; j--) {
                auto t = qb.front(); qb.pop();
                int x = t.first, y = t.second;
                if (!check(x, y, step)) continue;
                for (int k = 0; k < 4; k++) {
                    int nx = x + d[k], ny = y + d[k + 1];
                    if (check(nx, ny, step)) {
                        if (vis[nx][ny] == 2) return step;
                        if (!vis[nx][ny]) {
                            vis[nx][ny] = 1;
                            qb.push({nx, ny});
                        }
                    }
                }
            }

        for (int j = qg.size(); j; j--) {
            auto t = qg.front(); qg.pop();
            int x = t.first, y = t.second;
            if (!check(x, y, step)) continue;
            for (int k = 0; k < 4; k++) {
                int nx = x + d[k], ny = y + d[k + 1];
                if (check(nx, ny, step)) {
                    if (vis[nx][ny] == 1) return step;
                    if (!vis[nx][ny]) {
                        vis[nx][ny] = 2;
                        qg.push({nx, ny});
                    }
                }
            }
        }
    }

    return -1;
}

int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &m);
        for (int i = 0; i < n; i++) scanf("%s", g[i]);
        printf("%d\n", bfs());
    }

    return 0;
}

每组数据时空复杂度$O(NM)$。