噩梦（双向BFS）

给定一张N*M的地图，地图中有1个男孩，1个女孩和2个鬼。

字符“.”表示道路，字符“X”表示墙，字符“M”表示男孩的位置，字符“G”表示女孩的位置，字符“Z”表示鬼的位置。

男孩每秒可以移动3个单位距离，女孩每秒可以移动1个单位距离，男孩和女孩只能朝上下左右四个方向移动。

每个鬼占据的区域每秒可以向四周扩张2个单位距离，并且无视墙的阻挡，也就是在第k秒后所有与鬼的曼哈顿距离不超过2k的位置都会被鬼占领。

注意： 每一秒鬼会先扩展，扩展完毕后男孩和女孩才可以移动。

求在不进入鬼的占领区的前提下，男孩和女孩能否会合，若能会合，求出最短会合时间。

输入格式

第一行包含整数T，表示共有T组测试用例。

每组测试用例第一行包含两个整数N和M，表示地图的尺寸。

接下来N行每行M个字符，用来描绘整张地图的状况。（注意：地图中一定有且仅有1个男孩，1个女孩和2个鬼）

输出格式

每个测试用例输出一个整数S，表示最短会合时间。

如果无法会合则输出-1。

每个结果占一行。

---

emmmmm， 当时就打了个测试程序就回班了， 回来之后看到我的代码里有这个东西：

啊啊啊， 孟神， 你的算法进阶真不是我拿的啊。
进入正题--

求步数的话我们很容易想到BFS， 但这是两个人， 其实也很容易想到双向BFS， 创建两个队列， 在合法的状态下同时搜索， 当一个人搜索到另一个点人访问过的点时， 此时的步数就是最少步数；

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MAXN = 5e5 + ;
const int MAXM = 3e3 + ;

template < typename T > inline void read(T &x) {
    x = ; T ff = , ch = getchar();
    while(!isdigit(ch)) {
        if(ch == '-') ff = -;
        ch = getchar();
    }
    while(isdigit(ch)) {
        x = (x << ) + (x << ) + (ch ^ );
        ch = getchar();
    }
    x *=ff;
} 

template < typename T > inline void write(T x) {
    if(x < ) putchar('-'), x = -x;
    if(x > ) write(x / );
    putchar(x %  + '');
} 

int T, n, m;
int vis[MAXM][MAXM];
int dx[] = {, , -, };
int dy[] = {, , , -};
char ch[MAXM][MAXM];
pair < int, int > boy, girl,  ghost[];

// 梁神我的算法进阶是不是在你那 -- msm 

inline bool check(int xx, int yy, int dis) {
    if(xx <  || xx >= n || yy <  || yy >= m || ch[xx][yy] == 'X') return false;
    for(int i = ; i < ; ++i) {
        if(abs(xx - ghost[i].first) + abs(yy - ghost[i].second) <=  * dis) return false;
    }
    return true;
}

inline int BFS() {
    memset(vis, , sizeof(vis));
    queue < pair < int, int > > qb, qg;
    qb.push(boy);
    qg.push(girl);
    int dis = ;
    while(!qb.empty() || !qg.empty()) {
        ++dis;
        for(int i = ; i < ; ++i) {
            int len = qb.size();
            for(int j = ; j < len; ++j) {
                pair < int, int > x;
                x = qb.front();
                qb.pop();
                int a = x.first, b = x.second;
                if(!check(a, b, dis)) continue;
                for(int k = ; k < ; ++k) {
                    int u = a + dx[k], v = b + dy[k];
                    if(check(u, v, dis)) {
                        if(vis[u][v] == ) return dis;
                        if(!vis[u][v]) {
                            vis[u][v] = ;
                            qb.push({u, v});
                        }
                    }
                }
            }
        }
        int len = qg.size();
        for(int i = ; i < len; ++i) {
            pair < int, int > x;
            x = qg.front();
            qg.pop();
            int a = x.first, b = x.second;
            if(!check(a, b, dis)) continue;
            for(int k = ; k < ; ++k) {
                int u = a + dx[k], v = b + dy[k];
                if(check(u, v, dis)) {
                    if(vis[u][v] == ) return dis;
                    if(!vis[u][v]) {
                        vis[u][v] = ;
                        qg.push({u, v});
                    }
                }
            }
        }

    }
    return -;
}

int main() {
    read(T);
    while(T--) {
        read(n); read(m);
        for(int i = ; i < n; ++i) {
            scanf("%s", ch[i]);
        }
        int tot = ;
        for(int i = ; i < n; ++i) {
            for(int j = ; j < m; ++j) {
                if(ch[i][j] == 'M') boy = {i, j};
                else if(ch[i][j] == 'G') girl = {i, j};
                else if(ch[i][j] == 'Z') ghost[tot++] = {i ,j};
            }
        }
        write(BFS());
        puts("");
    }
    return ;
}