HDU - 3533 Escape

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!

题解：一副地图，让你从（0，0）走到（n，m），最少要多久

输入，n,m,k,d，k表示有k个炮塔，d表示有d点能量，走一步耗费一点，接下来k行

每行，炮台射击方向，射击间隔，子弹速度，坐标x，y；

在每个位置判断四个方向有无炮台，有的话有没有朝此点的炮，会不会打中，有没有射击别的方向的炮台遮挡，

如果某个方向的炮台已经置人死地，就不需要判断别的方向的炮台。

具体看的这篇博客：https://blog.csdn.net/libin56842/article/details/41909459

贴代码：

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
int n,m,k,d;
int nextt[5][2]= {0,0,0,1,1,0,0,-1,-1,0};
bool book[1010][110][110];//用int型定义提交显示memory limit
struct node
{
    int x,y,step;
};
struct lin
{
    char c;
    int t,v;
} mp[110][110];
void bfs()
{
    queue<node>q;
    node st,ed;
    int i,j,dis,tim,flag;
    st.x=0;
    st.y=0;
    st.step=0;
    book[0][0][0]=1;
    q.push(st);
    while(!q.empty())
    {
        st=q.front();
        q.pop();
        if(st.step>d)
            break;
        if(st.x==n&&st.y==m)
        {
            printf("%d\n",st.step);
            return ;
        }
        for(j=0; j<5; j++)
        {
            ed=st;
            int tx=st.x+nextt[j][0];
            int ty=st.y+nextt[j][1];
            int tp=st.step+1;
            if(tx<0||ty<0||tx>n||ty>m)
                continue;
            if(!mp[tx][ty].t&&!book[tp][tx][ty]&&tp<=d)//人不在炮塔且此时没来过此位置且时间小于d
            {
                flag=1;
                for(i=tx-1; i>=0; i--)//当位于此点，向北寻找是否有朝南方向射击的炮台
                {
                    if(mp[i][ty].t&&mp[i][ty].c=='S')//找到第一个炮台，且这个炮台是朝南射击的
                    {
                        dis=tx-i;//炮台与人的距离
                        if(dis%mp[i][ty].v)
                            break;//不能整除说明子弹不会停在这，反之有可能
                        tim=tp-dis/mp[i][ty].v;//离开的时间减去第一个子弹飞行到这个位置所需的时间
                        if(tim<0)
                            break;//为负数就是第一个子弹没有经过这个点，人安全，反之危险
                        if(tim%mp[i][ty].t==0)//能整除，说明有子弹刚好到这个点
                        {
                            flag=0;
                            break;
                        }
                    }
                    if(mp[i][ty].t)//找到了炮台而且不是朝南射击的，这个炮台会挡下所有子弹，所以北安全
                        break;
                }
                if(!flag)//如果这个方向就死了，后面不需要再看
                    continue;
                for(i=tx+1; i<=n; i++)
                {
                    if(mp[i][ty].t&&mp[i][ty].c=='N')
                    {
                        dis=i-tx;
                        if(dis%mp[i][ty].v)
                            break;
                        tim=tp-dis/mp[i][ty].v;
                        if(tim<0)
                            break;
                        if(tim%mp[i][ty].t==0)
                        {
                            flag=0;
                            break;
                        }
                    }
                    if(mp[i][ty].t)
                        break;
                }
                if(!flag)
                    continue;
                for(i=ty-1; i>=0; i--)
                {
                    if(mp[tx][i].t&&mp[tx][i].c=='E')
                    {
                        dis=ty-i;
                        if(dis%mp[tx][i].v)
                            break;
                        tim=tp-dis/mp[tx][i].v;
                        if(tim<0)
                            break;
                        if(tim%mp[tx][i].t==0)
                        {
                            flag=0;
                            break;
                        }
                    }
                    if(mp[tx][i].t)
                        break;
                }
                if(!flag)
                    continue;
                for(i=ty+1; i<=m; i++)
                {
                    if(mp[tx][i].t&&mp[tx][i].c == 'W')
                    {
                        dis=i-ty;
                        if(dis%mp[tx][i].v)
                            break;
                        tim=tp-dis/mp[tx][i].v;
                        if(tim<0)
                            break;
                        if(tim%mp[tx][i].t==0)
                        {
                            flag=0;
                            break;
                        }
                    }
                    if(mp[tx][i].t)
                        break;
                }
                if(!flag)
                    continue;
                book[tp][tx][ty]=1;
                ed.x=tx;
                ed.y=ty;
                ed.step=tp;
                q.push(ed);
            }
        }
    }
    printf("Bad luck!\n");
}
int main()
{
    while(~scanf("%d%d%d%d",&n,&m,&k,&d))
    {
        char s[10];
        int i,j;
        int t,v,x,y;
        memset(book,0,sizeof(book));
        memset(mp,0,sizeof(mp));
        for(i=0; i<k; i++)
        {
            scanf("%s%d%d%d%d",s,&t,&v,&x,&y);
            mp[x][y].t=t;
            mp[x][y].v=v;
            mp[x][y].c=s[0];//记录点（x，y）的情况。
        }
        bfs();
    }
    return 0;
}