題目描述

喬在迷宮中工作。不幸的是，迷宮的一部分著火了，迷宮的主人沒有制定火災的逃跑計劃。請幫助喬逃離迷宮。根據喬在迷宮中的位置以及迷宮的哪個方塊著火，你必須確定火焰燒到他之前，喬是否可以離開迷宮，如果能離開他能跑多快。
喬和火每分鐘移動一個方格，上、下、左、右，四個方向中的一個。火勢向四個方向同時蔓延。喬可以從迷宮的任何一個邊界逃離迷宮。無論是喬還是火都不會到達有牆的位置。

輸入

第一行輸入包含一個整數，即測試次數
每個測試用例的第一行包含兩個
整數R和C，用空格分隔，1≤R，C≤1000
下面R行中，每一行都包含C個字元，以及每個字元是以下之一：
# 代表牆
. 代表空地，火和喬是可通行的
J 喬在迷宮中最初的位置，火和喬是可通行的
F 代表火
在每組測試中只有一個J
 

輸出

對於每個測試用例，如果在火蔓延的時候燒到了喬，則喬無法逃出迷宮，輸出'IMPOSSIBLE'如果喬能逃出迷宮，則輸出喬最快可以在幾分鐘內安全逃出迷宮，每組輸出佔一行

樣例輸入

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

樣例輸出

3
IMPOSSIBLE

思路 ： 這個題我寫了兩個思路，第一個思路是雙bfs，第一個bfs遍歷全圖找到火到每一個點的最短速度 ，判斷人走到這裡

時的步數，是否小於最短速度，小於便能走；

下面是這個思路的程式碼

#include<iostream>
#include<stdio.h>
#include<queue>
#include<string.h>
#include<algorithm>
#include<string>
#include<stack>
#define ll long long
using namespace std;
char a[1005][1006];
int book[1005][1005];
int book1[1005][1005];
int vis[1005][1005] ;
int n,m,fx,fy,jx,jy;
const int MAXN = 99999 ;
const int dx[] = {0,0,1,-1};
const int dy[] = {1,-1,0,0};
struct Node
{
    int x,y,s;
    Node () {} 
    Node(int xx,int yy,int ss) : x(xx) , y(yy) , s(ss){}
};
int bfs(int x,int y,int s)
{
	memset(book1,0,sizeof(book1));
	book1[x][y] = 1 ;
    queue<Node> Q;
    Q.push(Node(x,y,s));
    book[x][y] = 0;
    while(!Q.empty())
    {
        Node u = Q.front() ;
        Q.pop() ;
        for(int i=0 ; i<4 ; i++)
        {
            int xx = u.x + dx[i] ;
            int yy = u.y + dy[i] ;
            int ss = u.s + 1 ;
            if(xx>=0 && yy>=0 && xx<n && yy<m && a[xx][yy] != '#' && book1[xx][yy] == 0)
            {
                //cout<<ss<<endl;
                //cout<<book[u.x][u.y]<<endl;
                book1[xx][yy] = 1 ;
                book[xx][yy] = min(book[xx][yy],ss) ;
                Q.push(Node(xx,yy,ss)) ;
            }
        }
        
    }
    return -1 ;
} 
void bfs1(int x,int y,int s)
{
    queue<Node> Q;
    Q.push(Node(x,y,s));
    vis[x][y] = 1 ;
    while(!Q.empty())
    {
        Node u = Q.front() ;
        Q.pop() ;
        if(u.x == 0  || u.y == 0 || u.x == n-1 || u.y == m-1)
        {
            printf("%d\n",u.s+1);
            return ;
        }
        for(int i=0 ; i<4 ; i++)
        {
            int xx = u.x + dx[i] ;
            int yy = u.y + dy[i] ;
            int ss = u.s + 1 ;
            if(xx>=0 && xx<n && yy>=0 && yy<m && a[xx][yy] != '#' && ss<book[xx][yy] && vis[xx][yy] == 0)
            {
                vis[xx][yy] = 1 ;
                Q.push(Node(xx,yy,ss));
            }
        }
    }
    printf("IMPOSSIBLE\n");
    return ;
    
    
}
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        for(int i=0 ; i<1005 ; i++)
        {
            for(int j=0 ; j<1005 ; j++)
            {
                book[i][j] = MAXN;
            }
        }
        memset(vis,0,sizeof(vis));
        memset(a,0,sizeof(a));
        //cout<<book[1][1]<<endl;
        cin>>n>>m;
        getchar();
        for(int i=0 ; i<n ; i++)
        {
            for(int j=0 ; j<m ; j++)
            {
                a[i][j] = getchar() ;
                if(a[i][j] == 'J')
                {
                    jx = i ;
                    jy = j ;
                }
            }
            getchar();
            

        }
        for(int i=0 ; i<n ; i++)
        {
            for(int j=0 ; j<m ; j++)
            
            
            {
                if(a[i][j] == 'F')
                {
                    bfs(i,j,0);
                }
            }
        }
    /*	for(int i=0 ; i<n ; i++)
        {
            for(int j=0 ; j<m ; j++)
            {
                cout<<book[i][j]<<" ";
            }
            cout<<endl;
        } */ 
        bfs1(jx,jy,0);
    }
    
    
    return 0;
}
 

第二個思路一個bfs就能解決問題，所有的火和人都放入佇列；

先放火再放人；先走火，火下一步能走的地方，人一定不能走把他變成 ‘#’ 

#include<iostream>
#include<stdio.h>
#include<queue>
#include<string.h>
#include<algorithm>
#include<string>
#include<stack>
#define ll long long
using namespace std;
char a[1150][1150];
int n,m,fx,fy,jx,jy;
const int inf = 0x3f3f3f3f;
const int dx[] = {1,-1,0,0};
const int dy[] = {0,0,1,-1};
struct Node
{
    int x,y,s,f;
    Node () {} 
    Node(int xx,int yy,int ss,int ff) : x(xx) , y(yy) , s(ss) ,f(ff){}
};
queue<Node> Q;
int bfs(int x,int y,int s,int ff)
{
	Q.push(Node(x,y,s,ff)) ; 
	while(!Q.empty())
	{
		Node u = Q.front() ;
		Q.pop() ;
		if((u.x == 0 || u.y == 0 || u.x == n-1 || u.y == m-1) && u.f==0)
		{
			return u.s + 1 ;
		}
		for(int i=0 ; i<4 ; i++)
		{
			int xx = u.x + dx[i] ;
			int yy = u.y + dy[i] ;

			if(xx>=0 && yy>=0 && xx<n && yy<m && a[xx][yy] != '#')
			{
				int ss = u.s + 1 ;
				int ff = u.f ;
				a[xx][yy] = '#' ;
				Q.push(Node(xx,yy,ss,ff)) ;
			}
		}
	}
	return -1 ; 
}
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
    	while(!Q.empty())
    	{
    		Q.pop() ;
	}
       // memset(book,inf,sizeof(book));
        scanf("%d%d",&n,&m);
      //  getchar();
        for(int i=0 ; i<n ; i++)
        {
            for(int j=0 ; j<m ; j++)
            {
               cin>>a[i][j] ; 
            }
          //  getchar();
        } 
        for(int i=0 ; i<n ; i++)
        {
            for(int j=0 ; j<m ; j++)       
            {
                if(a[i][j] == 'F')
                {
                    Q.push(Node(i,j,0,1));
                }
                if(a[i][j] == 'J')
                {
                	jx=i;
                	jy=j;
		}
            }
        }
       int ans =  bfs(jx,jy,0,0);
        if(ans==-1)
        {
       	    cout<<"IMPOSSIBLE"<<endl;
        }
	else
	{
	     cout<<ans<<endl;
	}
    }
    return 0;
}
 

多謝各位學長的思路，和幫忙debug ；