UVA-fire搜索解题

Fire! - UVA 11624 - Virtual Judge (vjudge.net)

题目大意：

你在一个迷宫,J表示起点,#表示墙，.表示路，F表示火。

F会向周边扩散，除了墙。问 你出这个迷宫的最短路是多少，如果出不去，输出impossible。

思路:先用BFS算得地图上每一个点F烧过来的时间。然后对J bfs，出迷宫的条件是能到达迷宫的外围又不被火烧。比如算得J两不就能到达迷宫边界，F要3步才烧得过来，就成功逃跑了。

一般来说，就输入地图，遇到J，就令startx=i，starty=j；遇到F，也记录这个点；

但是这道题可能没有F或者有多个F

在主函数得输入过程中

遇到多个F 可以这样

 else if (map[i][j] == 'F')
                {
                    fire[i][j] = 0;
                    q.push({ i,j,0 });
                }

另一个问题是 多个F 你在记录F烧过来得时间 要选小的哪个时间

所以给Fire[][]数组初始化很大，如果是F点-->0 

然后就可以进入第一个bfs算得火烧到每一个点得时间了

void bfs()
{
    while (!q.empty())
    {
        Node2 p = q.front(); q.pop();
        for (int i = 0; i < 4; i++)
        {
            int nx = p.x + dx[i];
            int ny = p.y + dy[i];
            int time = p.step + 1;
            if (time < fire[nx][ny])
            {
                if (nx >= 0 && ny >= 0 && nx < n && ny < m)
                {
                    fire[nx][ny] = time;
                    q.push({ nx,ny,time });
                }
              
              
            }
        }
    }
}

总代码-AC 

#include<iostream>
#include <queue>
#include<cstring>
#define int long long
using namespace std;
int n, m, t;
int jx, jy, fx, fy;
int dx[4] = { 1,0,-1,0 };
int dy[4] = { 0,-1,0,1 };
char map[1005][1005];
int vis[1005][1005];
int fire[1005][1005];
struct Node2
{
    int x; int y; int step;
};
queue<Node2>q;
queue<Node2>q2;
void bfs()
{
    while (!q.empty())
    {
        Node2 p = q.front(); q.pop();
        for (int i = 0; i < 4; i++)
        {
            int nx = p.x + dx[i];
            int ny = p.y + dy[i];
            int time = p.step + 1;
            if (time < fire[nx][ny])
            {
                if (nx >= 0 && ny >= 0 && nx < n && ny < m)
                {
                    fire[nx][ny] = time;
                    q.push({ nx,ny,time });
                }
              
              
            }
        }
    }
}
void bfs2()
{
    while (!q2.empty())
    {
        q2.pop();
    }
    q2.push({ jx,jy,0 });
    while (!q2.empty())
    {
        Node2 p = q2.front(); q2.pop();
        if (p.x == 0 || p.y == 0 || p.x == n - 1 || p.y == m - 1)
        {
            cout << p.step + 1 << endl;
            return;
        }
        for (int i = 0; i < 4; i++)
        {
            int nx = p.x + dx[i];
            int ny = p.y + dy[i];
            int ntime = p.step + 1;
            if (nx < 0 || ny < 0 || nx >= n || ny >= m || map[nx][ny] == '#' || vis[nx][ny] == 1 || ntime >= fire[nx][ny])continue;
            else {
                vis[nx][ny] = 1;
                q2.push({ nx,ny,ntime });
            }
        }
    }
    cout << "IMPOSSIBLE" << endl;
}
signed main()
{
    cin >> t;
    while (t--)
    {
        memset(vis, 0, sizeof(vis));
        memset(fire, 0, sizeof(fire));
        cin >> n >> m;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                cin >> map[i][j];
                fire[i][j] = n * m;
                if (map[i][j] == 'J')
                {
                    jx = i; jy = j;
                }
                else if (map[i][j] == 'F')
                {
                    fire[i][j] = 0;
                    q.push({ i,j,0 });
                }
                else if (map[i][j] == '#')
                {
                    fire[i][j] = 0;
                }
            }
        }
        bfs();
        bfs2();
    }
    return 0;
}