E - 【粉色】浣熊市下水道 （BFS，可移动障碍物）

E - 【粉色】浣熊市下水道 （BFS，可移动障碍物）

在浣熊市狭窄的下水道中，伴随着枪响，那颗本应射中艾达的子弹被浣熊市新晋警察里昂挡了下来。艾达无法理解里昂为什么会为她挡下这发子弹，但她还是将里昂拖到了安全的地方并用绷带治疗了里昂。由于任务在身，艾达不得已丢下了昏迷的里昂，继续去追击G病毒的创造者。当里昂逐渐恢复意识，他发现自己已经是弹尽粮绝，尽管下水道中拥有大量的感染者，但他还是想追上艾达。已知浣熊市下水道的平面图可以简化为一个nn行mm列的矩阵(3≤n,m≤500)(3≤n,m≤500)，其中有PP个僵尸(0≤P≤50)(0≤P≤50)，所有的这些僵尸会在一个1∗k(2≤k≤10)1∗k(2≤k≤10)的矩形中来回游走，撕咬所有它们碰到的猎物。好在这些僵尸并不会主动去出击，而只攻击自己闯上门来的倒霉蛋。里昂每次移动都会花费一个单位的时间，而且里昂也不能穿过墙壁、边界或者遇上僵尸，里昂甚至不能够停下，因为一旦停下休息他就没法再站起来。里昂太想赶快追上艾达，请你帮帮他最短需要多长时间才能追上艾达？

Input

第一行输入4个整数n,m,p,k(3≤n,m≤500,0≤P≤50,2≤k≤10)n,m,p,k(3≤n,m≤500,0≤P≤50,2≤k≤10),分别表示矩阵的行、列，僵尸的数量，僵尸来回走动的长度。

第2行到第n+1n+1行输入一个矩阵，每行输入一个字符串，第ii个字符串的第jj个字符表示矩阵中第ii行jj列的状态，如果字符是"#"表示是可以走的路，如果是"&"表示是下水道的墙壁。

第n+2行到第n+p+1n+p+1行每行输入两个整数x,yx,y和一个字符串，第ii行的数据表示第ii个僵尸当前时间会从第xx行yy列出发，沿着固有的方向前进K个单位时间后折返，再走回它之前的位置，再折返，依照这种方法循环下去。第三个字符串表示僵尸行进的方向，"UP"表示向上走，"LEFT"表示向左走，"DOWN"表示向下走，"RIGHT"表示向右走。数据保证在k个长度内僵尸不会碰到边界或者墙壁或者两个僵尸路径交错。

Output

如果里昂能够追上艾达，输出一行整数，表示里昂最短追上艾达的时间。

如果里昂不能追上艾达，输出一行"You are Dead!"(不包含引号)

Examples

Input

3 3 1 3
&&A
###
&&L
2 1 RIGHT

Output

2

Input

4 4 1 2
L#&A
##&#
#&##
####
3 3 DOWN

Output

You are Dead!

Note

样例一说明：

如果用*代表僵尸的位置，则起始时状态为

&&A
*##
&&L

一个单位时间后，里昂向上走，僵尸向右走，两者并没有碰上

&&A
#*L
&&#

再一个单位时间后，里昂向上走，追上艾达，达成目的。

&&L
##*
&&#

样例二说明：

初始状态

L#&A
##&#
#&*#
####

一单位时间后

##&A
L#&#
#&##
##*#

二单位时间后

##&A
##&#
L&*#
####

三单位时间后

##&A
##&#
#&##
L#*#

四单位时间后

##&A
##&#
#&*#
#L##

里昂如果再向左走的话就会跟僵尸碰个正着，而且不论里昂怎么往回走，在（4,3）总能遇见僵尸，所以里昂挂了。

 

 

思路：用三维数组存僵尸走到x，y的步数，比如fire[5][6][2] = 1 。表示在（5,6）点僵尸在第2步到达。用到了离散化将僵尸循环走的步数离散到1到2*（len-1）上。

 

代码：

#include <iostream>
#include <queue>
#include <string.h>

using namespace std;

typedef struct node {
    int x,y;
    int step;
} ty;

int n,m,p,k;
char a[505][505];
int fire[505][505][22];
int via[505][505];
ty t,d;
int nex[4][2] = {{1,0},{-1,0},{0,1},{0,-1} };// 下，上，右，左

int bfs( int x, int y )
{
    queue <ty> Q;
    t.x = x;
    t.y = y;
    t.step = 0;
    Q.push(t);
    via[x][y] = 1;
    while ( !Q.empty() ) {
        t = Q.front();
        Q.pop();

        if ( a[t.x][t.y] == 'A' ) {
            return t.step;
        }
        for ( int i=0; i<4; i++ ) {
            d.x = t.x + nex[i][0];
            d.y = t.y + nex[i][1];
            d.step = t.step + 1;

            if ( d.x<0||d.y<0||d.x>=n||d.y>=m ) {
                continue ;
            }
            if ( via[d.x][d.y]==0 && a[d.x][d.y]!='&' && fire[d.x][d.y][d.step%(2*k-2)]==0 ) {
                Q.push(d);
                via[d.x][d.y] = 1;
            }
        }
    }

    return -1;
}

int main()
{
    int i,j;
    char s[10];
    int x,y,pp,qq;
    cin >> n >> m >> p >> k;
    memset(via,0,sizeof(via));
    memset(fire,0,sizeof(fire));
    for ( i=0; i<n; i++ ) {
        for ( j=0; j<m; j++ ) {
            cin >> a[i][j];
            if ( a[i][j]=='L' ) {
                pp = i;
                qq = j;
            }
        }
    }
    for ( i=0; i<p; i++ ) {
        int isp;
        strcpy(s,"");
        cin >> x >> y >> s;
        x --;
        y --;
        if ( strcmp(s,"RIGHT")==0 ) {
            isp = 2;
        }
        else if ( strcmp(s,"LEFT")==0 ) {
            isp = 3;
        }
        else if ( strcmp(s,"UP")==0 ) {
            isp = 1;
        }
        else if ( strcmp(s,"DOWN")==0 ) {
            isp = 0;
        }
        for ( int j=0; j<k; j++ ) {
            fire[ x+nex[isp][0]*j ][ y+nex[isp][1]*j ][ j ] = 1; // 用nex数组来进行模拟僵尸走动
        }
        for ( int j=k; j<2*k; j++ ) {
            fire[ x+nex[isp][0]*(k*2-2-j) ][ y+nex[isp][1]*(k*2-2-j) ][ j ] = 1;
        }
    }
    int ans = bfs(pp,qq);
    if ( ans==-1 ) {
        cout << "You are Dead!" << endl;
    }
    else {
        cout << ans << endl;
    }

    return 0;
}