HDU 3533 Escape (BFS + 预处理)

Escape

Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 541    Accepted Submission(s): 141

Problem Description

The students of the HEU are maneuvering for their military training. The red army and the blue army are at war today. The blue army finds that Little A is the spy of the red army, so Little A has to escape from the headquarters of the blue army to that of the red army. The battle field is a rectangle of size m*n, and the headquarters of the blue army and the red army are placed at (0, 0) and (m, n), respectively, which means that Little A will go from (0, 0) to (m, n). The picture below denotes the shape of the battle field and the notation of directions that we will use later.The blue army is eager to revenge, so it tries its best to kill Little A during his escape. The blue army places many castles, which will shoot to a fixed direction periodically. It costs Little A one unit of energy per second, whether he moves or not. If he uses up all his energy or gets shot at sometime, then he fails. Little A can move north, south, east or west, one unit per second. Note he may stay at times in order not to be shot. To simplify the problem, let’s assume that Little A cannot stop in the middle of a second. He will neither get shot nor block the bullet during his move, which means that a bullet can only kill Little A at positions with integer coordinates. Consider the example below. The bullet moves from (0, 3) to (0, 0) at the speed of 3 units per second, and Little A moves from (0, 0) to (0, 1) at the speed of 1 unit per second. Then Little A is not killed. But if the bullet moves 2 units per second in the above example, Little A will be killed at (0, 1). Now, please tell Little A whether he can escape.

 

Input

For every test case, the first line has four integers, m, n, k and d (2<=m, n<=100, 0<=k<=100, m+ n<=d<=1000). m and n are the size of the battle ground, k is the number of castles and d is the units of energy Little A initially has. The next k lines describe the castles each. Each line contains a character c and four integers, t, v, x and y. Here c is ‘N’, ‘S’, ‘E’ or ‘W’ giving the direction to which the castle shoots, t is the period, v is the velocity of the bullets shot (i.e. units passed per second), and (x, y) is the location of the castle. Here we suppose that if a castle is shot by other castles, it will block others’ shots but will NOT be destroyed. And two bullets will pass each other without affecting their directions and velocities. All castles begin to shoot when Little A starts to escape. Proceed to the end of file.

 

Output

If Little A can escape, print the minimum time required in seconds on a single line. Otherwise print “Bad luck!” without quotes.

 

Sample Input

4 4 3 10 N 1 1 1 1 W 1 1 3 2 W 2 1 2 4 4 4 3 10 N 1 1 1 1 W 1 1 3 2 W 1 1 2 4

 

Sample Output

9 Bad luck!

 

 

 

 

 

非常纠结的一题，做了很久才做出来，题意非常不清楚，不推荐这题。

坑点：有碉堡的点不能走，人不会往回走，终点可能有碉堡。

先把所有可能被炮弹打到的点以及它被炮弹打到的时间标记出来，时间上限是初始能量值，因为超过了这个值就不能再走了，标记也就没意义。然后bfs搜的时候，用VIS[x][y][t]来判重，即当前点是否在第t秒以及走过了，我还加入了个曼哈顿距离来剪枝，如果当前点的剩余能量小于到终点的曼哈顿距离，那么就剪掉。

注意，更新x和y的时候，不必考虑向西和向北，因为终点是在东南方，刚开始我不确定这样对不对，但是去掉这两个点后依然能A，当然，也许是数据不够强，某个角落里还存在着一组诡异的数据，需要先绕回去几步，谁知道呢。

 

 #include <iostream>
 #include <cstdio>
 #include <queue>
 using    namespace    std;

 const    int    SIZE = ;
 const    int    UPDATE[][] = {{,},{,},{,}};
 int    N,M,K,E;
 bool    FIRE[SIZE][SIZE][];
 bool    VIS[SIZE][SIZE][];
 bool    CASTLE[SIZE][SIZE];
 struct    Node
 {
     int    x,y,t,e;
     bool    check(void)
     {
         if(x <  || x > N || y <  || y > M || t > E || VIS[x][y][t] || CASTLE[x][y] ||
           FIRE[x][y][t] || !e || N - x + M - y > e)
             return    false;
         return    true;
     }
 };
 struct    Cas
 {
     char    ch;
     int    t,v,x,y;
 };

 void    deal(char ch,int t,int v,int x,int y);
 void    bfs(void);
 int    main(void)
 {
     Cas    temp[];
     while(scanf("%d%d%d%d",&N,&M,&K,&E) != EOF)
     {
         fill(&FIRE[][][],&FIRE[SIZE - ][SIZE - ][],false);
         fill(&VIS[][][],&VIS[SIZE - ][SIZE - ][],false);
         fill(&CASTLE[][],&CASTLE[SIZE - ][SIZE - ],false);

         for(int i = ;i < K;i ++)
         {
             scanf(" %c%d%d%d%d",&temp[i].ch,&temp[i].t,&temp[i].v,&temp[i].x,&temp[i].y);
             CASTLE[temp[i].x][temp[i].y] = true;
         }
         if(CASTLE[N][M])
         {
             puts("Bad luck!");
             continue;
         }
         for(int i = ;i < K;i ++)
             deal(temp[i].ch,temp[i].t,temp[i].v,temp[i].x,temp[i].y);
         bfs();
     }

     return    ;
 }

 void    deal(char ch,int t,int v,int x,int y)
 {
     if(ch == 'W')
     {
         int    stop = ;
         for(int j = y - ;j >= ;j --)
             if(CASTLE[x][j])
             {
                 stop = j;
                 break;
             }
         for(int j = y - v,ini = ;j >= stop;j -= v,ini ++)
             for(int k = ini;k <= E;k += t)
                 FIRE[x][j][k] = true;

     }
     else    if(ch == 'E')
     {
         int    stop = M;
         for(int j = y + ;j <= M;j ++)
             if(CASTLE[x][j])
             {
                 stop = j;
                 break;
             }

         for(int j = y + v,ini = ;j <= stop;j += v,ini ++)
             for(int k = ini;k <= E;k += t)
                 FIRE[x][j][k] = true;
     }
     else    if(ch == 'N')
     {
         int    stop = ;
         for(int j = x - ;j >= ;j --)
             if(CASTLE[j][y])
             {
                 stop = j;
                 break;
             }
         for(int j = x - v,ini = ;j >= stop;j -= v,ini ++)
             for(int k = ini;k <= E;k += t)
                 FIRE[j][y][k] = true;
     }
     else    if(ch == 'S')
     {
         int    stop = N;
         for(int j = x + ;j <= N;j ++)
             if(CASTLE[j][y])
             {
                 stop = j;
                 break;
             }
         for(int j = x + v,ini = ;j <= stop;j += v,ini ++)
             for(int k = ini;k <= E;k += t)
                 FIRE[j][y][k] = true;
     }
 }

 void    bfs(void)
 {
     Node    first;
     first.x = first.y = first.t = ;
     first.e = E;
     queue<Node>    que;
     que.push(first);
     VIS[][][] = true;

     while(!que.empty())
     {
         Node    cur = que.front();
         que.pop();

         for(int i = ;i < ;i ++)
         {
             Node    next = cur;
             next.x += UPDATE[i][];
             next.y += UPDATE[i][];
             next.t ++;
             next.e --;
             if(!next.check())
                 continue;
             if(next.x == N && next.y == M)
             {
                 printf("%d\n",next.t);
                 return    ;
             }
             VIS[next.x][next.y][next.t] = true;
             que.push(next);
         }
     }
     puts("Bad luck!");
 }