uva 11624Fire! (bfs)

J - Fire!

需要两个BFS，第一个寻找每块空地被蔓延到的时间，第二个寻找人离开这里的最短路径，如果必须被烧到则输出IMPOSSIBLE

需要注意的就是人只有一个出发点，但是可以有N个着火点，N也可以为0，WA了无数次总结出来的。。

我这里直接用的G[MAX_N][MAX_N]来保存的地图。如果是墙，则为-1，是空地设置为INF，第一次bfs之后，G里面保存的是火到达每一个空地的时间（墙还是-1）

所以在第二次bfs人逃跑的时候，只要这个人可以赶在这个点着火之前通过就可以

/***********************************************
 * Author: fisty
 * Created Time: 2015/1/31 17:26:50
 * File Name   : Fire.cpp
 *********************************************** */
#include <iostream>
#include <cstring>
#include <deque>
#include <cmath>
#include <queue>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <cstdio>
#include <bitset>
#include <algorithm>
using namespace std;
#define Debug(x) cout << #x << " " << x <<endl
#define MAX_N 1010
const int INF = 0x3f3f3f3f;
typedef long long LL;
typedef pair<int, int> P;
int n, m;
int G[MAX_N][MAX_N];                //地图
int d[MAX_N][MAX_N];                //最短距离
int vis[MAX_N][MAX_N];              //标记有没有走过
int Jx, Jy;                        //起点
P F[MAX_N];                   //多个着火点
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};

void bfs(int cnt){
    queue<P> que; while(que.size()) que.pop();
    memset(vis, 0, sizeof(vis));
    for(int i = 0;i < cnt; i++){
        //把多个着火点放入队列
        G[F[i].first][F[i].second] = 0;
        vis[F[i].first][F[i].second] = 1;
        que.push(P(F[i].first, F[i].second));
    }
    //G[x][y] = 0;
    //que.push(P(x, y));
    while(que.size()){
        P q = que.front(); que.pop();
        for(int i = 0;i < 4; i++){
            int _x = q.first + dx[i], _y = q.second + dy[i];
            if(!vis[_x][_y] && G[_x][_y] == INF && _x >= 0 && _y >= 0 && _x < n && _y < m){
                G[_x][_y] = G[q.first][q.second] + 1;
                vis[_x][_y] = 1;
                que.push(P(_x, _y));
            }
        }
    }
}
int bfs_escape(int x, int y){
    queue<P> que;
    while(que.size()) que.pop();
    memset(d, 0x3f, sizeof(d));
    d[x][y] = 0;
    que.push(P(x, y));
    while(que.size()){
        P q = que.front(); que.pop();
        for(int i = 0;i < 4; i++){
            int _x = q.first + dx[i], _y = q.second + dy[i];
            if(_x < 0 || _y < 0 || _x >= n || _y >=  m){
                return d[q.first][q.second] + 1;
            }
            if(d[_x][_y] == INF && G[_x][_y] > d[q.first][q.second] + 1){
                //如果这个空地没有被大火蔓延并且没有走过
                d[_x][_y] = d[q.first][q.second] + 1;
                que.push(P(_x, _y));
            }
        }
    }
    return INF;
}
int main(){
    //freopen("in.cpp", "r", stdin);
    cin.tie(0);
    ios::sync_with_stdio(false);
    int T;
    cin >> T;
    while(T--){
        cin >> n >> m;
        int cnt = 0;
        for(int i = 0;i < n; i++){
            for(int j = 0;j < m; j ++){
                char c;
                cin >> c;
                if(c == '#'){
                    G[i][j] = -1;
                }else{
                    G[i][j] = INF;
                }
                if(c == 'J')
                    //起点
                    Jx = i, Jy = j;
                if(c == 'F'){
                    //多个着火点
                    F[cnt].first = i;
                    F[cnt++].second = j;
                }
            }
        }
        //计算各个地方的着火时间
        bfs(cnt);
        int ans = bfs_escape(Jx, Jy);
        if(ans == INF) cout << "IMPOSSIBLE" << endl;
        else cout << ans << endl;
    }
    return 0;
}