poj_3669_广度优先搜索

Meteor Shower

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 14384		Accepted: 3814

Description

Bessie hears that an extraordinary meteor shower is coming; reports say that these meteors will crash into earth and destroy anything they hit. Anxious for her safety, she vows to find her way to a safe location (one that is never destroyed by a meteor) . She is currently grazing at the origin in the coordinate plane and wants to move to a new, safer location while avoiding being destroyed by meteors along her way.

The reports say that M meteors (1 ≤ M ≤ 50,000) will strike, with meteor i will striking point (X_i, Y_i) (0 ≤ X_i ≤ 300; 0 ≤ Y_i ≤ 300) at time T_i (0 ≤ T_i  ≤ 1,000). Each meteor destroys the point that it strikes and also the four rectilinearly adjacent lattice points.

Bessie leaves the origin at time 0 and can travel in the first quadrant and parallel to the axes at the rate of one distance unit per second to any of the (often 4) adjacent rectilinear points that are not yet destroyed by a meteor. She cannot be located on a point at any time greater than or equal to the time it is destroyed).

Determine the minimum time it takes Bessie to get to a safe place.

Input

* Line 1: A single integer: M
* Lines 2..M+1: Line i+1 contains three space-separated integers: X_i, Y_i, and T_i

Output

* Line 1: The minimum time it takes Bessie to get to a safe place or -1 if it is impossible.

Sample Input

4
0 0 2
2 1 2
1 1 2
0 3 5

Sample Output

5

　　广搜，层次遍历，一开始并没有看懂，还是太菜...

　　如果是每次根据上层坐标的t(时间)值更新坐标点的话，一层更比一层高，只需比较当前层与上层的t(时间)值就不会往回走；

　　如果是直接计算t值，即x+y的话，还需要再设置一个类似visit[][]的函数，防止往上一层走；

　　此处采用第一种思路。

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <stack>
#include <queue>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <bitset>
#include <list>
#include <sstream>
#include <set>
#include <functional>
using namespace std;

#define INT_MAX 1 << 30
#define MAX 400
typedef long long ll;
int n;
struct node{
    int x;
    int y;
    int t;
}s,current;
queue<node>q;//寻找最短时间时层层推进
int map[MAX][MAX];//存储时间
int dir[5][2] = {{0,0},{0,1},{0,-1},{1,0},{-1,0}};//坐标的拓展

int bfs()//从坐标原点到MAX处层层前进
{
    if(map[0][0] == 0)  return -1;
    if(map[0][0] == -1) return 0;
    s.x = s.y = s.t = 0;
    q.push(s);
    while (!q.empty()){
        current = q.front();
        q.pop();
        for (int i = 0; i < 5; i += 1){//故伎重演，扩展每一层
            s.x = current.x+dir[i][0];
            s.y = current.y+dir[i][1];
            s.t = current.t+1;
            if(s.x < 0||s.x > MAX||s.y < 0||s.y > MAX)  continue;
            if(map[s.x][s.y] == -1) return s.t;
            if(s.t >= map[s.x][s.y])  continue;
            map[s.x][s.y] = s.t;
            q.push(s);
        }
    }
    return -1;
}

void in()
{
    memset(map,-1,sizeof(map));
    scanf("%d",&n);
    while(n--){
        int x,y,t;
        scanf("%d%d%d",&x,&y,&t);
        for (int i = 0; i < 5; i += 1){//扩展功能，map存放每个流星落点附近点的时间最小值
            int x1 = x+dir[i][0];
            int y1 = y+dir[i][1];
            if(x1 < 0||x1 >= MAX||y1 < 0||y1 >= MAX)  continue;
            if(map[x1][y1] == -1)    map[x1][y1] = t;
            else   map[x1][y1] = min(map[x1][y1],t);
        }
    }
}

int main()
{
    in();
    printf("%d\n",bfs());
    return 0;
}</span>

参考某大牛的思路：点击打开链接