Fire! -两次dfs

题目描述：

Joe works in a maze. Unfortunately, portions of the maze have caught on fire, and the owner of the maze neglected to create a fire escape plan. Help Joe escape the maze. Given Joe’s location in the maze and which squares of the maze are on fire, you must determine whether Joe can exit the maze before the fire reaches him, and how fast he can do it. Joe and the fire each move one square per minute, vertically or horizontally (not diagonally). The fire spreads all four directions from each square that is on fire. Joe may exit the maze from any square that borders the edge of the maze. Neither Joe nor the fire may enter a square that is occupied by a wall.

Input

The first line of input contains a single integer, the number of test cases to follow. The first line of each test case contains the two integers R and C, separated by spaces, with 1 ≤ R, C ≤ 1000. The following R lines of the test case each contain one row of the maze. Each of these lines contains exactly C characters, and each of these characters is one of: • #, a wall • ., a passable square • J, Joe’s initial position in the maze, which is a passable square • F, a square that is on fire There will be exactly one J in each test case.

Output

For each test case, output a single line containing ‘IMPOSSIBLE’ if Joe cannot exit the maze before the fire reaches him, or an integer giving the earliest time Joe can safely exit the maze, in minutes.

Sample Input

2

4 4

####

#JF#

#..#

#..#

3 3

###

#J.

#.F

Sample Output

3

IMPOSSIBLE

题意：Joe要逃离一个迷宫，迷宫中有地方起火了，在火开始燃烧的时候Joe也开始逃，火的蔓延方式与Joe的行动方式一样，都是1个单位时间可以往上下左右四个方向各走一格。另外，迷宫内有墙，Joe与火都无法穿墙。现在给你一个图，请问Joe能否从迷宫的边界处逃出而不被火烧到，如果能的话请输出最短的逃脱时间，不能的话输出“IMPOSSIBLE”。其中，‘F’代表火，‘J’代表Joe，‘#’代表墙。

解题思路：参考博客 https://blog.csdn.net/JZQT_T/article/details/38641127

这题首先注意的就是，起火点可能不止一个，也可能没有起火点。其次是如果一个起火点被四周的墙给封闭起来了，那么这个火就相当于没有用了。为了判断Joe走到某个点时这个点是否已经起火，我们需要知道每个点起火的时间。其实可以把每个初始起火点当成一个起火点的邻节点加入队列，这样就只进行了一次BFS，从而获得了每个点起火的时间（如果有些点不会起火，那么这些点的时间就是初始化的INF）。最后从Joe的起点开始BFS一次，如果走到下一个点时那个点已经或者刚好着火了那就不能走，墙也不能走，只要走到边界就说明可以走出迷宫了。

代码：

 //直接预处理出火烧到每一个格子的时间，bfsbfs的时候，已经有火在烧的格子和墙一样处理就行了,火烧时间的预处理也用bfsbfs就行
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #include <queue>

 using namespace std;

 #define N 1001
 #define INF 999999999

 struct point        //定义点结构体
 {
     int x, y;   //坐标
     int step;   //步数，相当于时间
 };

 int dx[] = {, -, , };   //方向向量
 int dy[] = {, , -, };   //方向向量

 int n, m, t;
 char map[N][N];
 int vis[N][N];          //记录火或者人到达点花费的最少时间
 point start, fire;      //起点和起火处
 queue <point> q;

 void FireBfs()
 {
     point a, b;
     while (!q.empty())
     {
         a = q.front();
         q.pop();
         for (int j=; j<; ++j)
         {
             int nx = a.x + dx[j];
             int ny = a.y + dy[j];
             if (nx <  || nx >= n || ny <  || ny >= m) continue;       //越界
             if (map[nx][ny] == '#' || vis[nx][ny] <= a.step + ) continue;  //墙或者已经走过的点
             b.x = nx;
             b.y = ny;
             //走到这一格的时间=火烧到这一格的时间=上一格的步数加1
             b.step = vis[nx][ny] = a.step + ;
             q.push(b);
         }
     }
     return;
 }

 void DataProcess()
 {
     point a, b;
     FireBfs();
     q.push(start);      //将人的起点加入队列准备Bfs
     while (!q.empty())
     {
         a = q.front();
         q.pop();
         for (int i=; i<; ++i)
         {
             int nx = a.x + dx[i];
             int ny = a.y + dy[i];
             if (nx <  || nx >= n || ny <  || ny >= m)     //成功走到边界
             {
                 printf("%d\n", a.step + );
                 return;
             }
             if (map[nx][ny] == '#' || vis[nx][ny] <= a.step + ) continue;  //遇到墙或者该点起火或者走过
             b.x = nx;
             b.y = ny;
             b.step = vis[nx][ny] = a.step + ;//走到这一步的时间=火烧到这一格的时间=上一格的步数加1
             q.push(b);
         }
     }
     puts("IMPOSSIBLE");
     return;
 }

 int main()
 {
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d %d", &n, &m);
         for (int i=; i<n; ++i)
         {
             scanf("%s", map[i]);
         }
         while (!q.empty()) q.pop();     //清空队列
         for (int i=; i<n; ++i)
         {
             for (int j=; j<m; ++j)
             {
                 vis[i][j] = INF;        //初始vis
                 if (map[i][j] == 'J')
                 {
                     start.x = i;
                     start.y = j;
                     start.step = ;
                     vis[i][j] = ;
                 }
                 else if (map[i][j] == 'F')
                 {
                     fire.x = i;
                     fire.y = j;
                     fire.step = ;
                     q.push(fire);           //加入队列准备进行火的Bfs
                     vis[i][j] = ;
                 }
             }
         }
         DataProcess();
     }
     return ;
 }