双向bfs

双向bfs

解空间

例如，一个bfs的解空间为

               st
              1  2
            3  4  5
         6  7  8  9  10
     11  12  13  14  15  16
  18 19 20 21 ans 22 23 24 25 26 

当用正常bfs从st起点向下搜索时，会发现，搜索空间不断变大，很可能会导致超时，那么我们就可以同时从ans和st进行搜索，可以减少解空间，降低时间复杂度。

              st
             1  2
            3  4  5
         6   7   8   9
      ....10  11  12 ....
    ........13  14 ........
  ............ans.............

思路：

为起点和终点分别设置一个队列，qs和qe。每次两个队列同时进行搜索，终止条件为用时搜索到同一个点。

bfs()
{
    定义队列qs, qe。
    qs.push(st);
    qe.push(ed);
    while (!qs.empty() && !qe.empty())
    {
        搜索qs
        {
            弹出队首；
            如果这个点被qe搜索过，返回答案。 
            将下一步符合的点放入队列。 
        } 

        搜索qe
        {
            同上。
        }
    }
}

例题：

HDU - 3085

给定一张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。

每个结果占一行。
数据范围

1<n,m<800

思路：

对于鬼来说，我们可以不用设置队列，因为他走的步数确定，起点确定，因此我们可以这样判断，如果当前的点距离鬼起点的距离小于等于step*2的话说明这个点被鬼占领。
其他的正常bfs即可。

代码

#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
#include<iostream>
using namespace std;
const int maxn=805;
char mapp[maxn][maxn];
int vis[maxn][maxn];
int n,m,step,ans;
int dir[4][2]= {0,1,1,0,0,-1,-1,0};
struct node
{
    int x,y;
} M,G,Z[2];
bool ok(int x,int y)
{
    if(x<0||x>=n||y<0||y>=m||mapp[x][y]=='X')
        return false;
    if(min(abs(x-Z[0].x)+abs(y-Z[0].y),abs(x-Z[1].x)+abs(y-Z[1].y))<=step*2)
        return false;
    return true;
}
void bfs()
{
    queue<node>qm;
    queue<node>qg;
    qm.push(M);
    qg.push(G);
    while(!qm.empty()&&!qg.empty())
    {
        step++;
        for(int k=0; k<3; k++)
            for(int i=0,len=qm.size(); i<len; i++)
            {
                node m=qm.front();
                qm.pop();
                if(!ok(m.x,m.y))
                    continue;
                for(int j=0; j<4; j++)
                {
                    node ext;
                    ext.x=m.x+dir[j][0];
                    ext.y=m.y+dir[j][1];
                    if(!ok(ext.x,ext.y)||vis[ext.x][ext.y]==3)
                        continue;
                    if(vis[ext.x][ext.y]==1)
                    {
                        ans=step;
                        return;
                    }
                    vis[ext.x][ext.y]=3;
                    qm.push(ext);
                }
            }
        for(int i=0,len=qg.size(); i<len; i++)
        {
            node g=qg.front();
            qg.pop();
            if(!ok(g.x,g.y))
                continue;
            for(int j=0; j<4; j++)
            {
                node ext;
                ext.x=g.x+dir[j][0];
                ext.y=g.y+dir[j][1];
                if(!ok(ext.x,ext.y)||vis[ext.x][ext.y]==1)
                    continue;
                if(vis[ext.x][ext.y]==3)
                {
                    ans=step;
                    return;
                }
                vis[ext.x][ext.y]=1;
                qg.push(ext);
            }
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        ans=0;
        step=0;
        memset(vis,0,sizeof(vis));
        scanf("%d%d",&n,&m);
        for(int i=0; i<n; i++)
            scanf("%s",mapp[i]);
        int z=0;
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
            {
                if(mapp[i][j]=='M')
                {
                    M.x=i;
                    M.y=j;
                    vis[i][j]=3;
                }
                else if(mapp[i][j]=='G')
                {
                    G.x=i;
                    G.y=j;
                    vis[i][j]=1;
                }
                else if(mapp[i][j]=='Z')
                {
                    Z[z].x=i;
                    Z[z].y=j;
                    z++;
                }
            }
        bfs();
        if(ans)
            printf("%d\n",ans);
        else
            printf("-1\n");
    }
}

//hdu 3085