Escape （bfs）

题目链接Escape
题目大意：小a从(0,0)点走到(n,m)点，地图上有k个碉堡，每个碉堡以周期为t，射速为v进行射击，战士碰到子弹时，战士死亡，且战士只能在整数点上碰到子弹，子弹撞上碉堡后子弹会消失，开始时所有碉堡都会射击。
思路：
我们可以开两个三维数组存储碉堡状态，和当前记录该点是否已经到达过，切记，后一个数组要用bool型或者char 型不然内存就爆了，然后在到达每个点时上下左右暴力跑一遍，看看该点是否安全，安全就入队列。

#include <iostream>
#include <cstring>
#include <queue>

using namespace std;

const int maxn = 105;
const int maxd = 1005;

int num[maxn][maxn][3];//num记录碉堡状态和位置
bool vis[maxn][maxn][maxd];//要用bool或者char型，不然内存爆了
int n,m,k,dl;
int dir[5][2]={{0,1},{1,0},{0,-1},{-1,0},{0,0}};

struct node     
{
    int x;
    int y;
    int step;
};

int bfs()
{
    memset(vis,0,sizeof(vis));
    queue <node> q;
    q.push(node{0,0,0});
    vis[0][0][0] = 1;
    while(!q.empty()){
        node now = q.front();
        q.pop();
        //超出规定时间
        if(now.step > dl){
            return -1;
        }
        //到达终点
        if(now.x == n&&now.y == m){
            return now.step;
        }
        for(int i = 0; i < 5; i++){
            int xx = now.x + dir[i][0];
            int yy = now.y + dir[i][1];
            int step = now.step + 1;
            //筛去不在途中，该点是碉堡，或者已经走过该点，时间超限的
            if(xx >= 0&&yy >= 0&&xx <= n&&yy <= m&&step <= dl&&!num[xx][yy][0]&&!vis[xx][yy][step]){
                int flag = 1;//该点是否安全的标记,1安全，0 没了
                //判断上方是否安全
                for(int i = xx - 1; i >= 0; i--){
                    //如果上方有碉堡且射击方向向下
                    if(num[i][yy][0]&&num[i][yy][2] == 'S'){
                        int dis  = xx - i;//距离碉堡的距离
                        //距离不能整除速度，就不会遇见子弹，安全
                        if(dis % num[i][yy][1]){
                            break;
                        }
                        //第一次发射子弹到该点的时间是否超过走到该点的时间
                        int if_reach = step - dis / num[i][yy][1];
                        //如果没到这个点，暂时安全
                        if(if_reach < 0){
                            break;
                        }
                        //看间隔，能整除，那么就是后续有子弹刚好到这个点，人死定了
                        if(if_reach % num[i][yy][0] == 0){
                            flag = 0;//子弹到达该点，over;
                            break;
                        }
                    }
                    //遇见碉堡就可以停下，挡子弹。。
                    if(num[i][yy][0]){
                        break;
                    }
                }
                if(!flag){
                    continue;
                }
                //向下判断,同上
                for(int i = xx + 1; i <= n; i++){
                    if(num[i][yy][0]&&num[i][yy][2] == 'N'){
                        int dis  = i - xx;
                        if(dis % num[i][yy][1]){
                            break;
                        }
                        int if_reach = step - dis / num[i][yy][1];
                        if(if_reach < 0){
                            break;
                        }
                        if(if_reach % num[i][yy][0] == 0){
                            flag = 0;
                            break;
                        }
                    }
                    if(num[i][yy][0]){
                        break;
                    }
                }
                if(!flag){
                    continue;
                }
                //向左判断，同上
                for(int i = yy - 1; i >= 0; i--){
                    if(num[xx][i][0]&&num[xx][i][2] == 'E'){
                        int dis  = yy - i;
                        if(dis % num[xx][i][1]){
                            break;
                        }
                        int if_reach = step - dis / num[xx][i][1];
                        if(if_reach < 0){
                            break;
                        }
                        if(if_reach % num[xx][i][0] == 0){
                            flag = 0;
                            break;
                        }
                    }
                    if(num[xx][i][0]){
                        break;
                    }
                }
                if(!flag){
                    continue;
                }
                //向右判断，同上
                for(int i = yy + 1; i <= m; i++){
                    if(num[xx][i][0]&&num[xx][i][2] == 'W'){
                        int dis  = i - yy;
                        if(dis % num[xx][i][1]){
                            break;
                        }
                        int if_reach = step - dis / num[xx][i][1];
                        if(if_reach < 0){
                            break;
                        }
                        if(if_reach % num[xx][i][0] == 0){
                            flag = 0;
                            break;
                        }
                    }
                    if(num[xx][i][0]){
                        break;
                    }
                }
                if(!flag){
                    continue;
                }
                vis[xx][yy][step] = 1;
                q.push(node{xx,yy,step});
            }
        }
    }
    return -1;
}

int main()
{
    while(cin>>n>>m>>k>>dl){
        memset(num,0,sizeof(num));
        while(k--){
            string d;
            int t,v,x,y;
            cin>>d>>t>>v>>x>>y;
            num[x][y][0] = t;//周期
            num[x][y][1] = v;//射速
            num[x][y][2] = d[0];//方向
        }
        int ans = bfs();
        if(ans == -1){
            cout<<"Bad luck!"<<endl;
        }
        else{
            cout<<ans<<endl;
        }
    }
}