BFS:Meteor Shower(POJ 3669)

　　　　　　　　　　　　   　　

　　　　　　　　　　　　　　    奔跑吧，傻牛

　　题目大意：这只Bessie的牛又要来闹事了，这次她的任务就是来躲流星雨，流星雨就是在一定时间会从天上砸到Bessie的所在的正方形区域内（Bessie在0，0的位置），然后砸下来后流星雨会把区域内的上下左右区域全部砸烂，并且砸烂后Bessie不能再到这里，Bessie也不能在流星雨打击的地方呆着（也就是只能在流星雨要下来的时间之前才能在这里），问你Bessie要走多少步才能到安全区域

　　这一道题好玩，我们这样想，Bessie走过的路就是等值的（也就是每走一步都是1），而且还要要求你在矩阵内走，那么这一题很明显就是要你用BFS了

　　但是关键的问题是，陨石不是一下子全部掉落下来的，而是有时间间隔的，那有这么一个思路，我们可以在一定区域时间内看牛能走到哪里，然后下一波流星雨，毁掉能走掉的部分区域，然后在下一波，这样我们只用保存最小的那一些路就可以了，但是这样的话显然是不现实的，因为有时候流星雨砸很长时间，但是一直砸不到某个区域，我们做的很多工作都是白费的，交题绝对TLE，不要问我为什么知道

　　所以我们要换一种思路，既然流星雨都会砸下来，那么我们为什么不直接先假设让流星雨先全部砸下来看剩下多少安全区域呢？？？（这是一种很好的思想，以后会经常用到），但是因为流星雨砸下来是有时间区分的，所以我们要保留流星雨砸下来的时间，然后从0，0开始BFS，如果BFS所用的步数不足以到达安全区域，那么就判断无法到达，如果能到到安全区域，那么第一次到达就肯定是最短的距离了（BFS的特性），

　　另外，还要注意，我们每次扫过位置以后，一定要对位置进行标记，可以使用known区域，但是一定要注意，一定要把四个方位区域全部标记上，而不是只标记出队的那个点，不这样做的话，重复会非常多，会TLE，或者直接把map写上当前最短距离，然后进行判断就可以了

　　另外一个小问题，原来我一直搞错了memset的工作原理，原来这玩意是按ANSCII来填字节的。。。。

　　

#include <iostream>
#include <functional>
#include <algorithm>
#include <queue>
#define MAX_N 310
#define MIN(a,b) a<b?a:b

using namespace std;

void Search(const int);
void Inivilize_dir(void);

pair<int, int>dir[4];
static int dp[MAX_N + 1][MAX_N + 1];
static int map[MAX_N + 1][MAX_N + 1];

void Inivilize_dir(void)
{
    dir[0].first = -1; dir[0].second = 0;
    dir[1].first = 1; dir[1].second = 0;
    dir[2].first = 0; dir[2].second = -1;
    dir[3].first = 0; dir[3].second = 1;
}

int main(void)
{
    int M, tx, ty, drop_time,ttx, tty;
    Inivilize_dir();
    while (~scanf("%d", &M))
    {
        memset(map, -1, sizeof(map));

        for (int i = 0; i < M; i++)
        {
            scanf("%d%d%d", &tx, &ty, &drop_time);
            if (map[tx][ty] != -1)
                map[tx][ty] = MIN(map[tx][ty], drop_time);//最早炸毁时间
            else map[tx][ty] = drop_time;
            for (int j = 0; j < 4; j++)//周围四个点都要
            {
                ttx = tx + dir[j].first;  tty = ty + dir[j].second;
                if (ttx >= 0 && ttx <= MAX_N
                    && tty >= 0 && tty <= MAX_N//坐标在矩阵内
                    )
                    if (map[ttx][tty] != -1)
                        map[ttx][tty] = MIN(map[ttx][tty], drop_time);
                    else map[ttx][tty] = drop_time;
            }
        }
        if (map[0][0] == 0) 
            cout << -1 << endl;
        else if (map[0][0] == -1)//开始都打不到还考虑什么，不动
            cout << 0 << endl;
        else Search(M);
    }
    return 0;
}

void Search(const int M)
{
    int ttx, tty, tx, ty;
    queue<pair<int, int>>que;
    pair<int, int>tmp, d_tmp;
    que.push(tmp);
    while (!que.empty())
    {
        tmp = que.front(); que.pop();
        tx = tmp.first; ty = tmp.second;

        for (int j = 0; j < 4; j++)
        {
            ttx = tx + dir[j].first;  tty = ty + dir[j].second;
            if (ttx >= 0 && ttx <= MAX_N
                && tty >= 0 && tty <= MAX_N//坐标在矩阵内
                )
            {
                if (map[ttx][tty] == -1)//如果找到安全位置，则更新最短距离
                {
                    cout << dp[tx][ty] + 1 << endl;
                    return;
                }
                if (dp[tx][ty] + 1 <= map[ttx][tty] - 1)//如果都比这个时间大，那肯定被炸死了
                {
                    dp[ttx][tty] = dp[tx][ty] + 1;
                    d_tmp.first = ttx; d_tmp.second = tty;
                    que.push(d_tmp);//还在时间之内，入队
                    map[ttx][tty] = dp[ttx][tty];
                    //不能用known去标记入口，除非是标记所有的点
                }
            }
        }
    }
    cout << -1 << endl;
}