UVA-11624 Fire! (BFS)

这题的一个做法是先对 'F' BFS一遍，这样就可以记录下来火势到达每一个格子最早的时间，对于每个 '.' 来说，在这个火到达的最早时间之前，joe是可以走的。然后对joe BFS 一遍就可以了，重点是joe在”边上“，也就是最左边最右边最上边最下边。

特别的是，我在bfs中采用的是每产生一个新的节点就判断一下是不是终点，所以对于joe一开始就在边上的情况需要额外判断。

#include<cstdio>
#include<climits>
#include<vector>
#include<queue>
using namespace std;
struct state
{
	int x, y, th;//th表示这是第几分钟
};
const int direction[][2] = { { 0,1 },{ 0,-1 },{ 1,0 },{ -1,0 } };
int r, c, rj, cj,time[1000][1000];
char maze[1000][1002];
bool vis[1000][1000];//记录是否被访问过
vector<pair<int, int>> fire;
queue<state> q;
inline bool inlaw(int a, int b)
{
	return a >= 0 && b >= 0 && a < r&&b < c&&maze[a][b] == '.';
}
void burn()
{
	for (int i = 0; i < r; i ++ )
		for (int j = 0; j < c; j++)
			if (maze[i][j] =='.') time[i][j] = INT_MAX;
	while (!q.empty()) q.pop();
	for (int i = 0; i < fire.size(); i++)
	{
		q.push({ fire[i].first,fire[i].second,0 });
		time[fire[i].first][fire[i].second] = 0;
	}
	int nx, ny;
	while (!q.empty())
	{
		state t = q.front(); q.pop();
		for (int i = 0; i < 4; i++)
		{
			nx = t.x + direction[i][0];
			ny = t.y + direction[i][1];
			if (inlaw(nx, ny) && time[nx][ny] == INT_MAX)
			{
				time[nx][ny] = time[t.x][t.y] + 1;
				q.push({ nx,ny,0 });
			}
		}
	}
}
int bfs()
{
	while (!q.empty()) q.pop();
	q.push({ rj,cj,0 });
	while (!q.empty())
	{
		state t = q.front(); q.pop();
		for (int i = 0; i < 4; i++)
		{
			int nx = t.x + direction[i][0], ny = t.y + direction[i][1];
			if (inlaw(nx,ny)&& !vis[nx][ny]&&t.th+1<time[nx][ny])
			{
				if (!nx || !ny || nx == r - 1 || ny == c - 1) return t.th + 2;
                            //+2是因为需要从上一个位置走到边界，再走出迷宫
				q.push({ nx,ny,t.th + 1 });
				vis[nx][ny] = true;
			}
		}
	}
	return 0;
}
int main()
{
	int T;
	scanf("%d", &T);
	while (T--)
	{
		scanf("%d%d", &r,&c);
		fire.clear();
		for (int i = 0; i < r; i++)
		{
			scanf("%s", maze[i]);
			for (int j = 0; j < c; j++)
			{
				if (maze[i][j] == 'J')
				{
					rj = i;
					cj = j;
					maze[i][j] = '.';
				}
				if (maze[i][j] == '.') vis[i][j] = false;
				else if (maze[i][j] == 'F') fire.push_back({ i,j });
			}
		}
		if (!rj || !cj || rj == r - 1 || cj == c - 1)
		{
			printf("1\n");
			continue;
		}
		burn();
		int t = bfs();
		if (t) printf("%d\n", t);
		else printf("IMPOSSIBLE\n");
	}
	return 0;
}

其实我本来用的是一种效率很低的土方法：

因为火可以蔓延到所有相邻的空地，但是joe不能走到火将在下一分钟蔓延到的地方，所以在对joe BFS每一层之前，先把火在这一分钟到的地方变成 ’F’。我的土土的实现方式是先记录下来所有初始的火位置，然后把下一分钟产生的火的位置记为 ‘F' ，同时记录下来新火的位置，因为只有这些火才能产生新的火。效率很低，但毕竟是我自己想的，记录一下

//这个版本使用了数组手动模拟的队列
#include<iostream>
#include<set>
using namespace std;
struct state
{
	int x, y, th;
};
const int direction[][2] = { {0,1},{0,-1},{1,0},{-1,0} };
state q[1000000];
int r, c,rj,cj,fire[50000][2],nfnum;
char maze[1000][1002];
bool vis[1000][1000];
inline bool inlaw(int a, int b)
{
	return a >= 0 && b >= 0 && a < r&&b < c&&maze[a][b]=='.';
}
void burn()
{
	set<pair<int, int>> t;
	int nx, ny;
	for(int i=0;i<nfnum;i++)
		for (int j = 0; j < 4; j++)
		{
			nx = fire[i][0]+direction[j][0], ny = fire[i][1]+direction[j][1];
			if (inlaw(nx, ny)) t.insert({ nx,ny });
		}
	nfnum = 0;
	for (set<pair<int, int>>::iterator it = t.begin(); it != t.end(); it++)
	{
		maze[(*it).first][(*it).second] = 'F';
		fire[nfnum][0] = (*it).first;
		fire[nfnum][1] = (*it).second;
		nfnum++;
	}
}
int bfs()
{
	int cur = 0, front = 0, rear = 1;
	state t;
	q[front].x = rj; q[front].y = cj;
	q[front].th = 0;
	while (front<rear)
	{
		t.x = q[front].x;
		t.y = q[front].y;
		t.th = q[front].th;
		front++;
		if (t.th != cur - 1)
		{
			cur++;
			burn();
		}
		for (int i = 0; i < 4; i++)
		{
			int nx = t.x + direction[i][0], ny = t.y + direction[i][1];
			if (inlaw(nx,ny)&& !vis[nx][ny])
			{
				if (!nx || !ny || nx == r - 1 || ny == c - 1) return t.th + 2;
				q[rear].x = nx;
				q[rear].y = ny;
				q[rear].th = t.th + 1;
				rear++;
				vis[nx][ny] = true;
			}
		}
	}
	return 0;
}
int main()
{
	int T;
	cin >> T;
	while (T--)
	{
		cin >> r >> c;
		nfnum = 0;
		for (int i = 0; i < r; i++)
		{
			cin >> maze[i];
			for (int j = 0; j < c; j++)
			{
				if (maze[i][j] == 'J')
				{
					rj = i;
					cj = j;
					maze[i][j] = '.';
				}
				if (maze[i][j] == '.') vis[i][j] = false;
				else if (maze[i][j] == 'F')
				{
					fire[nfnum][0] = i;
					fire[nfnum][1] = j;
					nfnum++;
				}
			}
		}
		if (!rj || !cj || rj == r - 1 || cj == c - 1)
		{
			cout << 1 << endl;
			continue;
		}
		int t = bfs();
		if (t) cout << t << endl;
		else cout << "IMPOSSIBLE" << endl;
	}
	return 0;
}