UVA-11624 Fire!（两遍BFS）

 

 

题意：

乔在一个迷宫中，迷宫里着火了，乔和火都可以想上下左右四个方向走，速度也是一样的，问乔能逃出去吗，如果能最少需要几步？

注意：着火的位置可能不止一处。

解题思路：

两遍BFS，第一遍先遍历火，并记录到每个地方的时间。第二遍遍历人，比较人能否在他逃生的路径上比火先到达。火不能够到达的地方的时间，记为无穷大。

#pragma GCC optimize("O3")
#pragma G++ optimize("O3")

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>


using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1010;

struct node{
    int x, y;
    int step;
    node(int x0 = 0, int y0 = 0, int step0 = 0) : x(x0), y(y0), step(step0) {}; // 构造函数
    friend bool operator < (node a, node b) // 重载 < 用与优先队列中优先级的判断方法。
    {
        return a.step > b.step;
    }
};

char g[N][N];
int used[N][N];
int time[N][N]; // 记录火到达每个点的时间

int d[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};   // 方向数组

int n, m;
queue<node> que;
priority_queue<node> que2;

void bfs()  // 遍历火,并记录火到达每个地方的时间
{
    memset(used, 0, sizeof(used));
    memset(time, 0, sizeof(time));

    
    while(!que.empty())
    {
        // printf("here\n");
        node e = que.front();   que.pop();
        for(int i=0; i<4; i++)
        {
            int dx = e.x + d[i][0];
            int dy = e.y + d[i][1];
            // printf("dx = %d dy = %d\n", dx, dy);
            if(dx >= 0 && dx < n && dy >= 0 && dy < m && g[dx][dy] != '#' && !used[dx][dy])
            {
                used[dx][dy] = 1;
                time[dx][dy] = time[e.x][e.y] + 1;  // 记录到达这个点的时间
                // printf("time[%d][%d] = %d\n", dx, dy, time[dx][dy]);
                que.push(node(dx, dy));
            }
        }
    }
    for(int i=0; i<n; i++)  
        for(int j=0; j<m; j++)
            if(time[i][j] == 0 && g[i][j] != '#')
                time[i][j] = INF;
}

int bfs2(int x, int y)  // 遍历人的逃生路径
{
    memset(used, 0, sizeof(used));
    while(!que2.empty()) que2.pop();


    que2.push(node(x, y, 1));   // 初始起点步数设为1，方便与时间比较
    used[x][y] = 1;
    while(!que2.empty())
    {
        node e = que2.top();   que2.pop();
        // printf("e.x = %d e.y = %d e.step = %d\n",e.x, e.y, e.step);
        if(e.x == 0 || e.x == n-1 || e.y == 0 || e.y == m-1)    // 如果在边线上，下一步就逃出去了
            return e.step;
        for(int i=0; i<4; i++)
        {
            int dx = e.x + d[i][0];
            int dy = e.y + d[i][1];
            if(dx >= 0 && dx < n && dy >= 0 && dy < m && !used[dx][dy] && e.step < time[dx][dy] && g[dx][dy] != '#')
            {
                used[dx][dy] = 1;
                que2.push(node(dx, dy, e.step + 1));
            }
        }
    }
    return 0;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--)
    {
        // int n, m;
        scanf("%d %d", &n, &m);
        for(int i=0; i<n; i++)
            scanf("%s", g[i]);
        int x1, y1, x2, y2;

        while(!que.empty()) que.pop();
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<m; j++)
            {
                if(g[i][j] == 'J')
                    x1 = i, y1 = j;
                else if(g[i][j] == 'F')    // 起始可能有多个地方着火
                {
                    que.push(node(i, j));
                    time[i][j] = 0;
                    used[i][j] = 1;
                }
            }
        }

        // printf("%d %d %d %d\n", x1, y1, x2, y2);
        
        bfs();
        int ans = bfs2(x1, y1);

        if(ans == 0)
            printf("IMPOSSIBLE\n");
        else
            printf("%d\n", ans);
    }



    return 0;
}