【简单搜索】Fire！

Fire！

题目描述

乔在迷宫中工作。不幸的是，迷宫的一部分着火了，迷宫的主人没有制定火灾的逃跑计划。请帮助乔逃离迷宫。根据乔在迷宫中的位置以及迷宫的哪个方块着火，你必须确定火焰烧到他之前，乔是否可以离开迷宫，如果能离开他能跑多快。
乔和火每分钟移动一个方格，上、下、左、右，四个方向中的一个。火势向四个方向同时蔓延。乔可以从迷宫的任何一个边界逃离迷宫。无论是乔还是火都不会到达有墙的位置。
输入 第一行输入包含一个整数，即测试次数 每个测试用例的第一行包含两个 整数R和C，用空格分隔，1≤R，C≤1000
下面R行中，每一行都包含C个字符，以及每个字符是以下之一：

#代表墙
. 代表空地，火和乔是可通行的
J 乔在迷宫中最初的位置，火和乔是可通行的
F 代表火
在每组测试中只有一个J

注意：在每组测试中，F是可以有多个的。

输出

对于每个测试用例，如果在火蔓延的时候烧到了乔，则乔无法逃出迷宫，输出’IMPOSSIBLE’如果乔能逃出迷宫，则输出乔最快可以在几分钟内安全逃出迷宫，每组输出占一行

样例输入

2
4 4
####
#JF#
#..#
#..#
3 3
###
#J.
#.F

思路

两次bfs。第一次广搜火源蔓延到每个位置的最短时间；第二次广搜Joe到达每个位置的最短时间，逃生路线必须要求它的每一个位置Joe到达的时间必须早于火到达的时间。
比较坑的地方在于，迷宫里火源可以有多个。。。

代码样例

//J-Fire!
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
#define MAXN 1010
int R, C;
char map[MAXN][MAXN];
int fire[MAXN][MAXN], Joe[MAXN][MAXN];
int direction[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
struct node{
	int x, y;
};
void fire_bfs(){
	//init()
	memset(fire, -1, sizeof(fire));
	node F;
	queue<node> Q;
	for(int i=0; i<R; i++){
		for(int j=0; j<C; j++){
			if(map[i][j]=='F'){
				F.x=i, F.y=j;
				fire[i][j]=0;
				Q.push(F);
			}
		}
	}
	while(Q.size()){
		F=Q.front(), Q.pop();
		for(int i=0; i<4; i++){
			node next=F;
			next.x+=direction[i][0];
			next.y+=direction[i][1];
			if(next.x<0||next.x>=R||next.y<0||next.y>=C) continue;
			if(map[next.x][next.y]=='#') continue;
			if(fire[next.x][next.y]!=-1) continue;
			fire[next.x][next.y]=fire[F.x][F.y]+1;
			Q.push(next);
		}
	}
}
int Joe_bfs(){
	//init()
	memset(Joe, -1, sizeof(Joe));
	node J;
	queue<node> Q;
	for(int i=0; i<R; i++){
		for(int j=0; j<C; j++){
			if(map[i][j]=='J'){
				J.x=i, J.y=j;
				Joe[i][j]=0;
				Q.push(J);
			}
		}
	}
	while(Q.size()){
		J=Q.front(), Q.pop();
		if(J.x==0||J.x==R-1||J.y==0||J.y==C-1){
			return Joe[J.x][J.y]+1;
		}
		for(int i=0; i<4; i++){
			node next=J;
			next.x+=direction[i][0];
			next.y+=direction[i][1];
			if(next.x<0||next.x>=R||next.y<0||next.y>=C) continue;
			if(map[next.x][next.y]=='#') continue;
			if(Joe[next.x][next.y]!=-1) continue;
			if(fire[next.x][next.y]!=-1&&Joe[J.x][J.y]+1>=fire[next.x][next.y]) continue;
			Joe[next.x][next.y]=Joe[J.x][J.y]+1;
			Q.push(next);
		}
	}
	return -1;
}
int main(void){
	int num;
	cin>>num;
	while(num--){
		cin>>R>>C;
		for(int i=0; i<R; i++){
			cin>>map[i];
		}
		fire_bfs();
		int ans=Joe_bfs();
		if(ans==-1){
			cout<<"IMPOSSIBLE"<<endl; 
		}else{
			cout<<ans<<endl;
		}
	}
	return 0;
}

还有一点值得注意，迷宫里可能有两个连通子图（但是测试样例好像没有考虑这种情况）。

if(fire[next.x][next.y]!=-1&&Joe[J.x][J.y]+1>=fire[next.x][next.y])
	continue;

必须要加上判断 fire[next.x][next.y]!=-1，意思是当火源能遍历到该位置时，Joe到达该位置的时间必须早于火蔓延到该位置的时间。而火不能遍历到该位置，意味着火源与该位置位于不同的连通子图，这就不需要考虑 Joe[J.x][J.y]+1>=fire[next.x][next.y]这种条件判断（考虑了反而是错的，因为fire数组初始化时元素全置为了-1），也就不需要单独拎出来了。

犯过的错误。。。

最开始时我想用双起点的bfs，把火与Joe之间的关系看成了竞争关系（但实际上它们之间是捕食关系，火“吃”人）。每个位置结点加上“到达者”属性，正常滴去广搜它们。
但是竞争有时意味着慌不择路，程序并不能找到最优的逃生路径（甚至不能找到一条逃生路径）。
现在也把错误的代码粘贴在这里：

//J-Fire!
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
#define MAXN 1010
int R, C;
int Jx, Jy, Fx, Fy;
char map[MAXN][MAXN];
int vist[MAXN][MAXN], direction[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
/*
** vist[i]==0, 结点未被遍历
** vist[i]==1，结点被人遍历
** vist[i]==2，结点被火遍历
** 被人遍历过的结点可以再次被火遍历，而被火遍历过的结点再被人遍历就GG
*/ 
struct node{
	int x, y, step;
	char arriver;
};
//对火焰属性结点的检查 
int fire_check(int _raw, int _column){
	if(_raw<0||_raw>=R||_column<0||_column>=C||vist[_raw][_column]==2||map[_raw][_column]=='#'){
		return 1;
	}
	return 0;
}
//对Joe属性的结点检查
int  Joe_check(int _raw, int _column){
	if(vist[_raw][_column]||map[_raw][_column]=='#'){
		return 1;
	}
	return 0;
} 
int bfs(){
	node J, F;
	J.x=Jx, J.y=Jy, F.x=Fx, F.y=Fy;
	J.step=F.step=0;
	J.arriver='J', F.arriver='F';
	queue<node> Q;
	Q.push(F), Q.push(J);
	while(Q.size()){
		node current=Q.front();
		Q.pop();
		if(current.arriver=='J'&&(current.x==0||current.x==R||current.y==0||current.y==C)){
			return current.step;
		}
		for(int i=0; i<4; i++){
			node next=current;
			next.x+=direction[i][0];
			next.y+=direction[i][1];
			//current是火遍历到的结点
			if(current.arriver=='F'){
				if(fire_check(next.x, next.y)) continue;
				vist[next.x][next.y]=2;
				next.step++;
				Q.push(next);
			}
			//current是Joe遍历到的结点
			if(current.arriver=='J'){
				if(Joe_check(next.x, next.y)) continue;
				vist[next.x][next.y]=1;
				next.step++;
				Q.push(next);
			}
		}
	}
	return -1;
}
int main(void){
	int num;
	cin>>num;
	while(num--){
		cin>>R>>C;
		for(int i=0; i<R; i++){
			cin>>map[i];
			for(int j=0; j<C; j++){
				if(map[i][j]=='J'){
					Jx=i, Jy=j;
				}
				if(map[i][j]=='F'){
					Fx=i, Fy=j;
				}
			}
		}
		memset(vist, 0, sizeof(vist));
		int ans=bfs();
		if(ans==-1){
			cout<<"IMPOSSIBLE"<<endl;
		}else{
			cout<<ans<<endl;
		}
	}
	return 0;
}

• 1605集训计划第十天任务
• 按时完成