HDU [ Catch him ]——BFS以点带面

Problem Description

在美式足球中，四分卫负责指挥整只球队的进攻战术和跑位，以及给接球员传球的任务。四分卫是一只球队进攻组最重要的球员，而且一般身体都相对比较弱小，所以通常球队会安排5-7名大汉来保护他，其中站在四分卫前方、排成一线的5名球员称为进攻锋线，他们通常都是135公斤左右的壮汉。<br><img src=../../../data/images/2531-1.jpg><br>对防守方来说，攻击对手的四分卫当然是最直接的限制对手进攻的方法。如果效果好，就可以在对方四分卫传球之前将其按翻在地，称之为擒杀。擒杀是最好的鼓舞防守队士气的方法，因为对方连传球的机会都没有，进攻就结束了，还必须倒退一些距离开球。凶狠的擒杀甚至能够将对方的四分卫弄伤，从而迫使对方更换这个进攻核心。<br>在本题中，输入给出准备擒杀四分卫的防守球员的位置、对方每个进攻锋线球员的位置以及对方四分卫的位置，你的任务是求出这名准备擒杀的防守球员至少要移动多少步，才能够擒杀对方四分卫。<br>假设对方进攻锋线和四分卫在这个过程中都不会移动。只有1名防守球员，防守球员只要碰到对方四分卫就算擒杀。<br>所有的球员都是一块连续的、不中空的2维区域。防守球员不可以从进攻锋线的身体上穿过，也不可以从界外穿过(只能走空地)。<br>防守队员不可以转动身体，只能平移。防守队员的身体所有部分向同一个方向(上、下、左、右)移动1格的过程叫做1步。<br>

 

Input

输入包含多组数据。每组数据第一行都是两个整数H，W(0<H,W<=100)，表示整个区域的高度和宽度，H=W=0表示输入结束。接下来有H行，每行W个字符。每个字符如果是’.’，表示这里是空地，如果是’O’，表示是进攻锋线队员的身体，如果是’D’，表示是准备擒杀的防守球员的身体，如果是’Q’，表示是四分卫的身体。<br>输入保证符合上面的条件。防守球员的身体总共不超过20格。<br><br>

 

Output

对每组数据，输出包含擒杀所需最少步数的一行。如果不能擒杀，输出带’Impossible’的一行。

 

Sample Input

6 6

.Q....

QQ..OO

.OO..O

...O.O

OO.O..

....DD

7 7

.Q.....

QQ.OOO.

...O...

O......

OO..OO.

.O.....

.....DD

0 0

 

Sample Output

Impossible9

==============================================================

         这题看着好像比较复杂，不过只要想清楚了还是挺简单的，还是一个基本的BFS最短路问题，难点就在于我们在移动点时要移动并判断一个点集，因此我们可以用两个数组去存储防守队员的位置，同时因为是BFS问题，我们要用到队列，所以我们将这两个数组定义在结构体里面。

        其次，关于bfs是否能进入下一层的判断，及最后是否有点捕杀四分卫，我们可以分别用两个函数实现（这两个函数很关键）。

        最后关于标记走过的点的问题，我们在这里用第一个点代替整个面标记。同时注意只要有一个点到达四分卫的位置，就结束bfs函数。

AC代码：

#include<bits/stdc++.h>
using namespace std;
char a[106][106];
bool flag[106][106];
int b[6]={0,1,-1,0,0};
int c[6]={0,0,0,-1,1};
int h,w,num=0;  //num用于记录防守队员所占的体积（点的个数）。
struct point
{
    int xx[50],yy[50],step;  //队列中的元素应该存储一个点集。
}p,q;
bool move(point &x,int k)  //该函数用于判断除第一个点之外，其余的点是否能到达下一位置；同时这里用了传引用，若符合条件，所有点均移动，否则，在bfs中给实参重新复制
{
    for(int i=2;i<=num;++i)
    {
        x.xx[i]+=b[k];
        x.yy[i]+=c[k];
        if(!(x.xx[i]>=1&&x.xx[i]<=h&&x.yy[i]>=1&&x.yy[i]<=w))return 0;
        else {

            if(a[x.xx[i]][x.yy[i]]=='O')return 0;
        }
    }
    return 1;
}
bool last(point x)  //该函数用于判断在移动一步后，点集中是否有捕杀Q的点。
{
    for(int i=1;i<=num;++i)
    {
        if(a[x.xx[i]][x.yy[i]]=='Q')return 1;
    }
    return 0;
}
int bfs(point x) //宽搜：定义队列、队首元素赋值并入队、标记第一层队首、取队首元素讨论所有走法并赋给新的队列元素、判断是否能走、新元素入队并标记。。。
{
    q=x; //这里的实参、形参、存储当前位置的结构体、存储下一位置的结构体它们之间的关系一定要弄清楚，第一次在这里错了。
    queue <point> Q;
    q.step=0;
    flag[q.xx[1]][q.yy[1]]=1;
    Q.push(q);
    while(!Q.empty())
    {
        q=Q.front();
        Q.pop();
        for(int i=1;i<=4;++i)
        {
            p=q;
            p.step=q.step+1;

            p.xx[1]=q.xx[1]+b[i];
            p.yy[1]=q.yy[1]+c[i];

            if(flag[p.xx[1]][p.yy[1]]==0&&p.xx[1]>=1&&p.xx[1]<=h&&p.yy[1]>=1&&p.yy[1]<=w)// flag 以点带面。
            {
                if(move(p,i)==1)
                {
                    flag[p.xx[1]][p.yy[1]]=1;
                    if(last(p)==1)return p.step;
                    Q.push(p);
                }

            }
        }

    }
    return -1;

}
int main()
{
    
   while(cin>>h>>w&&h+w!=0)
   {
       point t;
       num=0;  //以下3行，在多组测试数据的题目中一定要有（还有bfs中的队列一般是一次一定义）。
       memset(a,0,sizeof(a));
       memset(flag,0,sizeof(flag));
       for(int i=1;i<=h;++i)
       {
           getchar();
           for(int j=1;j<=w;++j)
           {
               scanf("%c",&a[i][j]);
               if(a[i][j]=='O')flag[i][j]=1;
               if(a[i][j]=='D')
               {
                   num++;
                   t.xx[num]=i;
                   t.yy[num]=j;
               }
           }
       }
       int ans=bfs(t);//过去写的bfs一般直接传几个整形变量，然后在函数内赋给结构体并入队；这里因为是一个点集，所以在输入时便将其赋给一个结构体。
       if(ans>=0)cout<<ans<<endl;
       else cout<<"Impossible"<<endl;
   }
   return 0;
}

The end；