BFS Fire! UVA - 11624

在一个矩形方阵里面,一个人要从一个位置走向另一个位置,其中某些地方有火源,每过一分钟,火源就会点燃相邻的点,同时相邻的点也变成了火源。人不能通过有火的点。问一个人能够安全地走到边界去最短时间多少?Unfortunately, portions of the maze havecaught on fire。portions of 是一些的意思。

两次bfs,首先从着火的点开始BFS进行预处理,在BFS求最短路。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<queue>
#include<cstring>
#include<string>
#include<cstring>
using namespace std;
#define inf 0x3f3f3f
char a[1005][1005];
int dis[1005][1005];
int n,m,jx,jy;
int nex[4][2]= {{0,1},{1,0},{0,-1},{-1,0} };
typedef struct
{
    int x,y;
} Point;
int boundary(int x,int y)
{
    return (x>=0&&x<n&&y>=0&&y<m) ;

}
int judge(int x,int y)
{
    return (x==0||y==0||x==n-1|y==m-1);
}
void fire_bfs()
{
    queue<Point>q;
    Point f1,f2;
    memset(dis,inf,sizeof(dis));
    for(int i=0; i<n; i++)
        for(int j=0; j<m; j++)
        {
            if(a[i][j]==‘F‘)
            {
                f1.x=i,f1.y=j;
                dis[i][j]=0;
                q.push(f1);
            }
        }

    while(!q.empty())
    {
        f1=q.front();
        q.pop();
        for(int i=0; i<4; i++)
        {
            f2.x=f1.x+nex[i][0];
            f2.y=f1.y+nex[i][1];
            if(boundary(f2.x,f2.y)&&a[f2.x][f2.y]==‘.‘&&dis[f2.x][f2.y]>dis[f1.x][f1.y]+1)
            {
                dis[f2.x][f2.y]=dis[f1.x][f1.y]+1;
                q.push(f2);
            }
        }
    }

}
int bfs()
{
    queue<Point>q;
    Point f1,f2;
    f1.x=jx,f1.y=jy;
    dis[jx][jy]=0;
    q.push(f1);
    while(!q.empty())
    {
        f1=q.front();
        if(judge(f1.x,f1.y)) return dis[f1.x][f1.y]+1;//注意判断的位置
        q.pop();
        for(int i=0; i<4; i++)
        {
            f2.x=f1.x+nex[i][0];
            f2.y=f1.y+nex[i][1];
            if(boundary(f2.x,f2.y)&&a[f2.x][f2.y]==‘.‘&&dis[f2.x][f2.y]>dis[f1.x][f1.y]+1)
            {
                dis[f2.x][f2.y]=dis[f1.x][f1.y]+1;
                q.push(f2);
            }
        }
    }
    return 0;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=0; i<n; i++)
        {
            getchar();
            for(int j=0; j<m; j++)
            {
                scanf("%c",&a[i][j]);
                if(a[i][j]==‘J‘) jx=i,jy=j;
            }
        }
        fire_bfs();
        int c=bfs();
        if(c==0) printf("IMPOSSIBLE\n");
        else printf("%d\n",c);
    }
    return 0;
}
时间: 2024-10-12 04:04:39

BFS Fire! UVA - 11624的相关文章

J - Fire!---UVA 11624

题目链接 题意:J代表Joe的位置,F代表火的起点,下一刻火将会向四周扩散,求Joe逃离的最短时间,如果不能逃离输出IMPOSSIBLE; 注意火的起点可能不止一处 可以用两次bfs分别求出人到达某个位置所用时间和火到达某个位置所用时间 1 #include<iostream> 2 #include<stdio.h> 3 #include<string.h> 4 #define INF 0xfffffff 5 #include<queue> 6 #inclu

Fire uva 11624

题目连接:http://acm.hust.edu.cn/vjudge/problem/28833 /* 首先对整个图bfs一次得到火焰燃烧的时刻表 之后在bfs搜路径时加一个火烧表的判断 坑点在于:如果时刻表等于0应该是从未烧过...如果不加以区分就会wa */ #include <bits/stdc++.h> #define scan(x) scanf("%d",&x) #define M(x) memset(x,0,sizeof(x)) #define REF(

uva 11624 Fire!(多源BFS)

uva 11624 Fire! 题目大意:J在迷宫里工作,有一天迷宫起火了,火源有多处.每过一秒,火源都会向四个方向蔓延,J也会向四个方向移动,问J能不能跑出去,能的话输出他跑出去的最短时间,否则输出"IMPOSSIBLE" 解题思路:先进行一次BFS,找出每一点火焰蔓延到该处的最短时间.然后根据这张"火势图",对J的行进路线进行BFS.注意J在边缘的时候,以及没有火源的时候. #include <cstdio> #include <cstring

BFS(两点搜索) UVA 11624 Fire!

题目传送门 1 /* 2 BFS:首先对火搜索,求出火蔓延到某点的时间,再对J搜索,如果走到的地方火已经烧到了就不入队,直到走出边界. 3 */ 4 /************************************************ 5 Author :Running_Time 6 Created Time :2015-8-4 8:11:54 7 File Name :UVA_11624.cpp 8 ****************************************

UVA 11624 - Fire!(BFS)

UVA 11624 - Fire! 题目链接 题意:一个迷宫,一些格子着火了,火每秒向周围蔓延,现在J在一个位置,问他能走出迷宫的最小距离 思路:BFS2次,第一次预处理每个位置着火时间,第二次根据这个再BFS一次 代码: #include <cstdio> #include <cstring> #include <queue> using namespace std; const int d[4][2] = {0, 1, 1, 0, 0, -1, -1, 0}; co

UVa 11624 Fire!(着火了!)

p.MsoNormal { margin: 0pt; margin-bottom: .0001pt; text-align: justify; font-family: "Times New Roman"; font-size: 10.5000pt } h3 { margin-top: 5.0000pt; margin-bottom: 5.0000pt; text-align: left; font-family: 宋体; font-weight: bold; font-size: 1

UVA 11624 UVA 10047 两道用 BFS进行最短路搜索的题

很少用bfs进行最短路搜索,实际BFS有时候挺方便得,省去了建图以及复杂度也降低了O(N*M): UVA 11624 写的比较挫 #include <iostream> #include <cstdio> #include <cstring> #include <queue> using namespace std; struct node{ int ft; int sta; }flo[1010][1010]; int vis[1010][1010]; st

逆向+两次bfs(UVA 1599)

为什么都说简单好想咧.坦白从宽看了人家的代码,涨了好多姿势,, http://blog.csdn.net/u013382399/article/details/38227917 被一个细节坑了.. 2147483647是0x7fffffff啊啊啊,7个f!!! 1 #include <iostream> 2 #include <sstream> 3 #include <cstdio> 4 #include <cstring> 5 #include <c

UVa 11624 Fire!(BFS 逃离火灾)

题意   n*m的迷宫中有一些着火点  每个着火点上下左右相邻的非墙点下一秒也将成为一个着火点  Joe每秒能向相邻的点移动一步  给你所有着火点的位置和Joe的位置  问Joe逃离这个迷宫所需的最小时间 可以先一遍bfs把每个点的最早着火时间存起来   只有Joe到达该点的时间小于这个时间Joe才能走这个点   只需要对Joe所在的点为起点再来一次bfs就行了   需要注意的是开始可能有多个着火点  我开始以为只有一个着火点被坑了好久 v[i][j]第一遍bfs记录点i,j的最早着火时间  第