Nightmare Ⅱ HDU - 3085 (双向bfs)

题目链接

题意：在一个迷宫有两个ghost，每秒可以走2格并且可以穿墙，boy每秒可以走3格，girl每秒1格，每次是ghost先移动然后人移动，问boy和girl能否在遇到ghost之前碰面。如果可以输出最小秒数，否则输出-1

思路：同时从M G开始bfs，bfs的轮数从1开始枚举，如果在某一轮他们相遇了，就说明搜到了。这个轮数就是最小的秒数
每秒 M搜三层 ，G搜一层 。
用曼哈顿距离判断某个点能否走。

注意这里每次bfs时，要取出当前层搜到的所有节点来搜下一层，代码中用count记录

#include<iostream>
#include<cstdio>
#include<set>
#include<vector>
#include<map>
#include<algorithm>
#include<string.h>
#include<string>
#include<queue>
using namespace std;
#define ll long long
#define ull unsigned long long 
const int maxn = 8e2+5;
const ll inf = 34359738370;
const int INF = 1e9+7;
const int has = 99959;
//迷宫 鬼每秒分裂并占据2格以内的位置 boy每秒3步 girl每秒1步 
//问相遇最短时间
//双向bfs  t时间内能否相遇 枚举t  
int n,m;
char g[maxn][maxn];
bool vis[2][maxn][maxn];//1 girl   0 boy   
int bx,by,gx,gy;
int ghost[2][2],cnt=0;
int dx[4]={-1,1,0,0},dy[4]={0,0,1,-1};
struct node
{
    int x,y;
}h;
queue<node> q[2];
void init()
{
    memset(ghost,0,sizeof(ghost));
    cnt=0;
    memset(vis,0,sizeof(vis));
    while(q[0].size()) q[0].pop();
    while(q[1].size()) q[1].pop();
}
bool bfs(int x,int ret)//这里就和普通的bfs没有啥区别
{
    int count=q[x].size();
    while(count--)
    {
        h=q[x].front(),q[x].pop();
        //之前可以走的点此时也可能被鬼占领 所以也要判断一次
        if(abs(ghost[0][0]-h.x) + abs(ghost[0][1]-h.y)<=2*ret) continue;
        if(abs(ghost[1][0]-h.x) + abs(ghost[1][1]-h.y)<=2*ret) continue;
        for(int i=0;i<4;i++)
        {
            int x1=h.x+dx[i],y1=h.y+dy[i];
            if(x1<1 || x1>n || y1<1 || y1>m || g[x1][y1]=='X' || vis[x][x1][y1]) continue;
            
            if(abs(ghost[0][0]-x1) + abs(ghost[0][1]-y1)<=2*ret) continue;
            if(abs(ghost[1][0]-x1) + abs(ghost[1][1]-y1)<=2*ret) continue;
            
            vis[x][x1][y1]=1;
            if(vis[1][x1][y1] && vis[0][x1][y1]) return 1;
            q[x].push({x1,y1});
        }
    }
    return 0;
}
int solve()
{
    int ret=0;
    q[0].push({bx,by}),q[1].push({gx,gy});
    vis[0][bx][by]=vis[1][gx][gy]=1;
    while(q[0].size() || q[1].size())
    {
        ret++;
        if(bfs(0,ret))
            return ret;
        if(bfs(0,ret))
            return ret;
        if(bfs(0,ret))
            return ret;
        if(bfs(1,ret))
            return ret;
    }
    return -1;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d %d",&n,&m);
        init();
        for(int i=1;i<=n;i++)
        {   
            scanf("%s",g[i]+1);
            for(int j=1;j<=m;j++)
            {
                if(g[i][j]=='G') gx=i,gy=j;
                else if(g[i][j]=='M') bx=i,by=j;
                else if(g[i][j]=='Z') ghost[cnt][0]=i,ghost[cnt++][1]=j;
            }
        }
        cout<<solve()<<'\n';
    }
    return 0;
}

PS：这题可以作为双向bfs的模板题， 开两个队列，两个标记数组，
每轮开始2个起点各自搜一层，每次搜索要取出队列当前的所有节点（也就是当前层的全部节点），然后往下拓展一层。 当标记交叉了就说明在当前层数相遇。