UVA 11624 Fire!-优快云博客

本文介绍了一种解决迷宫逃脱问题的算法，通过广度优先搜索(BFS)来寻找角色J逃离充满火焰的迷宫的最短路径。算法考虑了火焰蔓延的特性，确保角色在火焰到达前逃离。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：

J要逃出迷宫，F代表火焰，点着后会向上下左右四个方向蔓延，火蔓延到的地方F都不能走，问F是否可以逃出去

思路：

可以先广搜一遍标记火药到达每个地方的最短时间，再跑F，F只能在标记的时刻之前走过（白书方法）

其实这题就是求J走出迷宫的最短路，只是多了一个火焰的限制条件，那么我们可以把F和J一起放进队列，每秒F经过的地方J就不能再走了即可，J走过的地方也不能再走（*一定要先放F再放J），用个id标记塞进队列的是J还是F

注意，这题可能不存在F，因为这个WA了好多把

代码如下：

#include<cstdio>  
#include<cstring>
#include<queue>
using namespace std;
#define INF 1e7+9
typedef long long ll; 
const int N = 1010; 

struct node
{
	int x, y, t, id;
};

int n, m, ans, sum;
bool map[N][N]; 
char str[N];
queue<node>q;

int f[4][2] = {0, 1, 1, 0, 0, -1, -1, 0};

bool ok(int x ,int y)
{
   if(x >= 0 && x < n && y >= 0 && y < m && !map[x][y]) return true;
   return false;
}

int bfs()
{
	node nex;
	while(!q.empty())
	{
	    node a = q.front();
		q.pop();
		for(int i = 0; i < 4; i++)
		{
			nex.x = a.x + f[i][0];
			nex.y = a.y + f[i][1];
			nex.t= a.t + 1;
			nex.id = a.id;
			if(nex.id && (nex.x == -1 || nex.x == n || nex.y == -1 || nex.y == m))
					 return nex.t;
			if(ok(nex.x, nex.y))
			{
				map[nex.x][nex.y] = 1;
				q.push(nex); 
			}
		}
	}
	return -1;
}

int main()
{
	int t;
	scanf("%d", &t);
	while(t--)
	{
		node s1, s2;
		scanf("%d%d", &n, &m);
		while(!q.empty()) q.pop();
		for(int i = 0; i < n; i++)
		{
			scanf("%s", str);
		    for(int j = 0; j < m; j++)
		    {
		    	if(str[j] == '.') map[i][j] = 0;
            	else if(str[j] == '#') map[i][j] = 1;
		    	else if(str[j] == 'F') 
		    	{
		    		map[i][j] = 1, s1.x = i, s1.y = j, s1.t = 0, s1.id = 0;
		    		q.push(s1); 
		    	}
					 
		    	else if(str[j] == 'J') 
					 map[i][j] = 1, s2.x = i, s2.y = j, s2.t = 0, s2.id = 1;
		    }
		}   
		q.push(s2); 
		int ans = bfs();
		ans == -1 ? puts("IMPOSSIBLE") : printf("%d\n", ans);
	}
	return 0;
}