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 #include<algorithm>
  7 using namespace std;
  8 #define N 1010
  9
 10 int dir[4][2]={ {1,0},{-1,0},{0,-1},{0,1} };
 11 char map[N][N];
 12 int people[N][N], fire[N][N];//分别代表人和火到达该位置的时间;
 13 int n, m, k, vis[N][N];
 14 struct node
 15 {
 16     int x,y;
 17 }f[N*N];//火的位置;可能不止一处;
 18
 19 void FireBfs()
 20 {
 21     queue<node> Q;
 22     node p, q;
 23     memset(vis, 0, sizeof(vis));
 24     memset(fire, -1, sizeof(fire));
 25     for(int i=0; i<k; i++)
 26     {
 27         Q.push(f[i]);
 28         fire[f[i].x][f[i].y] = 1;
 29         vis[f[i].x][f[i].y]=1;
 30     }
 31     while(Q.size())
 32     {
 33         p = Q.front(); Q.pop();
 34         for(int i=0; i<4; i++)
 35         {
 36             q.x=p.x+dir[i][0];
 37             q.y=p.y+dir[i][1];
 38             if(q.x>=0 && q.y>=0 && q.x<n && q.y<m && vis[q.x][q.y]==0 && map[q.x][q.y]!=‘#‘)
 39             {
 40                 fire[q.x][q.y] = fire[p.x][p.y] + 1;
 41                 vis[q.x][q.y] = 1;
 42                 Q.push(q);
 43             }
 44         }
 45     }
 46 }
 47 int PeopleBfs(node s)
 48 {
 49     queue<node> Q;
 50     node p, q;
 51     memset(vis, 0, sizeof(vis));
 52     memset(people, -1, sizeof(people));
 53     Q.push(s);
 54     people[s.x][s.y] = 1;
 55     vis[s.x][s.y] = 1;
 56     while(Q.size())
 57     {
 58         p = Q.front(); Q.pop();
 59         if(p.x==0||p.x==n-1||p.y==0||p.y==m-1)
 60         {
 61             if((people[p.x][p.y] != -1 && people[p.x][p.y]<fire[p.x][p.y]) || (people[p.x][p.y] != -1&&fire[p.x][p.y] == -1) )//能到达边界并且在火到达之前;
 62                 return people[p.x][p.y];
 63         }
 64
 65         for(int i=0; i<4; i++)
 66         {
 67             q.x = p.x + dir[i][0];
 68             q.y = p.y + dir[i][1];
 69             if(q.x>=0 && q.x<n && q.y>=0 && q.y<m && vis[q.x][q.y]==0 && map[q.x][q.y]!=‘#‘)
 70             {
 71                 people[q.x][q.y] = people[p.x][p.y] + 1;
 72                 vis[q.x][q.y] = 1;
 73                 Q.push(q);
 74             }
 75         }
 76     }
 77     return -1;
 78 }
 79 int main()
 80 {
 81     int T;
 82
 83     scanf("%d", &T);
 84     while(T--)
 85     {
 86         node J;
 87         scanf("%d%d", &n, &m);
 88         k = 0;
 89         for(int i=0; i<n; i++)
 90         {
 91             scanf("%s", map[i]);
 92             for(int j=0; j<m; j++)
 93             {
 94                 if(map[i][j]==‘J‘)
 95                     J.x = i, J.y = j;
 96                 if(map[i][j]==‘F‘)
 97                     f[k].x = i,f[k++].y = j;
 98             }
 99         }
100         FireBfs();
101         int ans = PeopleBfs(J);
102         if(ans==-1)
103             printf("IMPOSSIBLE\n");
104         else
105             printf("%d\n", ans);
106     }
107     return 0;
108 }

时间: 2024-10-10 00:36:39

J - Fire!---UVA 11624的相关文章

BFS Fire! UVA - 11624

在一个矩形方阵里面,一个人要从一个位置走向另一个位置,其中某些地方有火源,每过一分钟,火源就会点燃相邻的点,同时相邻的点也变成了火源.人不能通过有火的点.问一个人能够安全地走到边界去最短时间多少?Unfortunately, portions of the maze havecaught on fire.portions of 是一些的意思. 两次bfs,首先从着火的点开始BFS进行预处理,在BFS求最短路. #include<iostream> #include<cstdio>

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

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

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

BFS [uva 11624] Fire!

J - Fire! Time Limit:1000MS     Memory Limit:0KB     64bit IO Format:%lld & %llu Problem B: Fire! Joe works in a maze. Unfortunately, portions of the maze have caught on fire, and the owner of the maze neglected to create a fire escape plan. Help Joe

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

UVa 11624 Fire!(BFS 逃离火灾)

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