HDU4528 小明系列故事——捉迷藏(BFS)

Problem Description

　小明的妈妈生了三个孩子，老大叫大明， 老二叫二明， 老三…， 老三自然就叫小明了。
　　一天，小明的妈妈带小明兄弟三人去公园玩耍，公园里面树木很多，有很多地方可以藏身，
于是他们决定玩捉迷藏。经过几轮的猜拳后，第一轮是小明来找其他两个人，游戏规则很简单：
　　只要小明可以在规定的时间内找到他们就算小明获胜，并且被发现的两个人猜拳决定谁在下一轮负责找人；如果在规定的时间内只找到一个人，那么没有被发现的人获胜，被找到的人下一轮负责找人；如果在规定的时间内一个人都没有找到，则小明失败了，下一轮还是他来找人。现在小明想知道，在规定时间内，自己是否可以找到所有的人，现在他想请你来帮忙计算一下。
　　为了简单起见，把公园看成是n行m列的矩阵，其中’S’表示小明，’D’表示大名，’E’表示二明，’X’表示障碍物，’.’表示通路。这里，我们把发现定义为，可以直接看到对方，
也就是说两个人在同一行或者同一列，并且中间没有障碍物或者没有其他人就可以看到对方。并且假设，大明，二明藏好以后就不会再改变位置，小明每个单位时间可以从当前的位置走到相邻的四个位置之一，并且不会走出公园。

Input

测试数据第一行是一个正整数T，表示有T组测试数据。
每一组测试数据首先是三个正整数n,m,t，分别表示行数、列数和规定的时间，接下来n行，每行m个上述的字符，并且保证有且只有一个’S’，一个’E’，一个’D’。

[Technical Specification] T < 200 3 <= n, m <= 100 0 <= t <= 100

Output

每组先输出一行Case c:(c表示当前的组数，从1开始计数)；
接下来一行，如果小明可以在规定时间内找到所有的人，则输出最少需要的时间，否则输出-1。

Sample Input

3
5 6 3
XXD...
....E.
....X.
....S.
......
5 6 3
XDX...
....E.
......
....S.
......
5 6 8
XXDX..
.XEX..
......
....S.
......

Sample Output

Case 1:
-1
Case 2:
3
Case 3:
-1

思路

本题有几个要点:

把发现定义为，可以直接看到对方， 也就是说两个人在同一行或者同一列，并且中间没有障碍物或者没有其他人就可以看到对方

所以当小明看见了大明或者二明，但是这两个人紧挨着，那么小明只能看见一个人，当前这个人也算做一个障碍物,比如样例3。

我们可以设置一个变量flag来表示当前的状态，然后利用二进制中的或运算，当最后的结果通过或运算变成3的时候，证明现在已经找到了，可以直接输出结果。我们先找到大明和二明的坐标进行预处理，并存入dp数组里面，通过或运算就知道了大明二明所在的十字路线上的所有的状态，然后进行广搜。在判断条件的时候要判断，越界，当前状态是否被标记过，步数是不是满足条件，当前走的是不是.或者S(起点可以重复走)

代码

#include <bits/stdc++.h>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
const int N=100+10;
int sx,sy,ex,ey,dx,dy,n,m,k;
char e[N][N];
int vis[N][N][10],dp[N][N];
int go[4][2]= {1,0,-1,0,0,1,0,-1};
void init(int x,int y,int c)
{
    for(int i=x-1; i>=0; i--)
    {
        if(e[i][y]=='.'||e[i][y]=='S')
        {
            dp[i][y]|=c;
            continue;
        }
        break;
    }
    for(int i=x+1; i<n; i++)
    {
        if(e[i][y]=='.'||e[i][y]=='S')
        {
            dp[i][y]|=c;
            continue;
        }
        break;
    }
    for(int i=y-1; i>=0; i--)
    {
        if(e[x][i]=='.'||e[x][i]=='S')
        {
            dp[x][i]|=c;
            continue;
        }
        break;
    }
    for(int i=y+1; i<m; i++)
    {
        if(e[x][i]=='.'||e[x][i]=='S')
        {
            dp[x][i]|=c;
            continue;
        }
        break;
    }
}
struct node
{
    int x,y,step;
    int flag;
};
int bfs(int x,int y)
{
    queue<node>q;
    node now,to;
    now.x=x,now.y=y,now.step=0,now.flag=dp[x][y];
    mem(vis,0);
    vis[x][y][now.flag]=0;
    q.push(now);
    while(!q.empty())
    {
        now=q.front();
        q.pop();
        if(now.flag==3)
            return now.step;
        for(int i=0; i<4; i++)
        {
            to.x=now.x+go[i][0];
            to.y=now.y+go[i][1];
            to.step=now.step+1;
            to.flag=now.flag|dp[to.x][to.y];
            if(to.x>=0&&to.x<n&&to.y>=0&&to.y<m&&!vis[to.x][to.y][to.flag]&&to.step<=k&&(e[to.x][to.y]=='.'||e[to.x][to.y]=='S'))
            {
                vis[to.x][to.y][to.flag]=1;
                q.push(to); 
            }
        }
    }
    return -1;
}
int main()
{
    int t,q=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d",&n,&m,&k);
        for(int i=0; i<n; i++)
        {
            scanf("%s",e[i]);
            for(int j=0; j<m; j++)
            {
                if(e[i][j]=='S')
                {
                    sx=i;
                    sy=j;
                }
                if(e[i][j]=='D')
                {
                    dx=i;
                    dy=j;
                }
                if(e[i][j]=='E')
                {
                    ex=i;
                    ey=j;
                }
            }
        }
        mem(dp,0);
        init(ex,ey,2);
        init(dx,dy,1);
        printf("Case %d:\n%d\n",q++,bfs(sx,sy));
    }
    return 0;
}