I - Fire! UVA - 11624

最新推荐文章于 2024-09-07 21:06:05 发布
最新推荐文章于 2024-09-07 21:06:05 发布
阅读量365 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： BFS 错误反思 文章标签： 2点BFS 队列思想 时间优化 反思-数组越界
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/BlessingXRY/article/details/72596825
该博客主要介绍了如何解决UVA 11624问题，采用两点BFS策略进行预处理，计算火蔓延到每个节点的时间，并在第二遍遍历中判断是否存在逃离迷宫的路径及最短时间。作者强调了在实现过程中需要注意时间复杂度优化和避免数组越界的问题，并给出了Time Limit Exceeded、Runtime Error以及Accepted的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Think:
1两点BFS，第一遍预处理火到每个结点的时间，第二遍遍历判断是否可以走出迷宫，以及得到走出迷宫的最短时间
2注意时间和数组越界

vjudge题目链接

以下为Time limit Exceeded代码——未优化+数组越界（尚未判断）

#include <cstdio>
#include <cstring>
#define Inf 0x3f3f3f3f

using namespace std;

struct node
{
    int x, y;
    int step;
} link_J[1040000], link_F[1040000], p, q;

int n, m, u[104][104];
bool v[104][104];
char st[104][104];
int jk[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

void BFS();
bool Judge(int dx, int dy);

int main()
{
    int T, i;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d %d", &n, &m);
        for(i = 0; i < n; i++)
            scanf("%s", st[i]);
        BFS();
    }
    return 0;
}
bool Judge(int dx, int dy)
{
    if(dx < 0 || dx >= n || dy < 0 || dy >= m)
        return false;
    else
        return true;
}
void BFS()
{
    int jo, jt, fo, ft, i, j, a, b, c, d;
    int flag = -1;
    for(i = 0; i < n; i++)
        for(j = 0; j < m; j++)
            u[i][j] = Inf;
    for(i = 0; i < n; i++)
    {
        for(j = 0; j < m; j++)
        {
            if(st[i][j] == 'F')
            {
                c = i, d = j;
                flag += 1;
            }
            else if(st[i][j] == 'J')
            {
                a = i, b = j;
                flag += 1;
            }
            if(flag == 1)
                break;
        }
        if(flag == 1)
            break;
    }

    jo = jt = fo = ft = 0;
    memset(v, true, sizeof(v));
    p.x = c;
    p.y = d;
    p.step = 0;
    link_F[ft++] = p;
    v[p.x][p.y] = false;
    u[p.x][p.y] = 0;
    while(fo < ft)
    {
        p = link_F[fo];
        for(i = 0; i < 4; i++)
        {
            q.x = p.x + jk[i][0];
            q.y = p.y + jk[i][1];
            q.step = p.step + 1;
            if(Judge(q.x, q.y) && v[q.x][q.y] && st[q.x][q.y] != '#')
            {
                v[q.x][q.y] = false;
                u[q.x][q.y] = q.step;
                link_F[ft++] = q;
            }
        }
        fo++;
    }

    flag = 0;
    memset(v, true, sizeof(v));
    p.x = a;
    p.y = b;
    p.step = 0;
    if(p.step < u[p.x][p.y])
    {
        link_J[jt++] = p;
        v[p.x][p.y] = false;
    }
    while(jo < jt)
    {
        p = link_J[jo];
        if(p.x == 0 || p.x == n-1 || p.y == 0 || p.y == m-1)
        {
            flag = 1;
            printf("%d\n", p.step+1);
            break;
        }
        for(i = 0; i < 4; i++)
        {
            q.x = p.x + jk[i][0];
            q.y = p.y + jk[i][1];
            q.step = p.step + 1;
            if(Judge(q.x, q.y) && v[q.x][q.y] && q.step < u[q.x][q.y] && st[q.x][q.y] != '#')
            {
                v[q.x][q.y] = false;
                link_J[jt++] = q;
            }
        }
        jo++;
    }
    if(!flag)
        printf("IMPOSSIBLE\n");
}

以下为Runtime Error代码——数组越界

#include <cstdio>
#include <cstring>
#define Inf 0x3f3f3f3f

using namespace std;

struct node
{
    int x, y;
    int step;
} link_J[1040000], link_F[1040000], p, q;

int n, m, a, b, fo, ft, u[104][104];
bool v[104][104];
char st[104][104];
int jk[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

void BFS();
bool Judge(int dx, int dy);

int main()
{
    int T, i, j;
    scanf("%d", &T);
    while(T--)
    {
        fo = ft = 0;
        memset(v, true, sizeof(v));
        for(i = 0; i < n; i++){
            for(j = 0; j < m; j++){
                u[i][j] = Inf;
            }
        }

        scanf("%d %d", &n, &m);
        for(i = 0; i < n; i++){
            scanf("%s", st[i]);
            for(j = 0; j < m; j++){
                if(st[i][j] == 'F'){
                    v[i][j] = false;
                    u[i][j] = 0;
                    p.x = i, p.y = j, p.step = 0;
                    link_F[ft++] = p;
                }
                else if(st[i][j] == 'J'){
                    a = i, b = j;
                }
            }
        }
        BFS();
    }
    return 0;
}
bool Judge(int dx, int dy)
{
    if(dx < 0 || dx >= n || dy < 0 || dy >= m)
        return false;
    else
        return true;
}
void BFS()
{
    int jo, jt, i, flag;

    while(fo < ft)
    {
        p = link_F[fo];
        for(i = 0; i < 4; i++)
        {
            q.x = p.x + jk[i][0];
            q.y = p.y + jk[i][1];
            q.step = p.step + 1;
            if(Judge(q.x, q.y) && v[q.x][q.y] && st[q.x][q.y] != '#')
            {
                v[q.x][q.y] = false;
                u[q.x][q.y] = q.step;
                link_F[ft++] = q;
            }
        }
        fo++;
    }

    flag = 0, jo = jt = 0;;
    memset(v, true, sizeof(v));
    p.x = a;
    p.y = b;
    p.step = 0;
    if(p.x == 0 || p.x == n-1 || p.y == 0 || p.y == m-1)
    {
        flag = 1;
        printf("%d\n", p.step+1);
    }
    else if(p.step < u[p.x][p.y])
    {
        link_J[jt++] = p;
        v[p.x][p.y] = false;
    }

    while(jo < jt)
    {
        p = link_J[jo];
        for(i = 0; i < 4; i++)
        {
            q.x = p.x + jk[i][0];
            q.y = p.y + jk[i][1];
            q.step = p.step + 1;
            if(Judge(q.x, q.y) && v[q.x][q.y] && q.step < u[q.x][q.y] && st[q.x][q.y] != '#')
            {
                v[q.x][q.y] = false;
                link_J[jt++] = q;
                if(q.x == 0 || q.x == n-1 || q.y == 0 || q.y == m-1)
                {
                    flag = 1;
                    printf("%d\n", q.step+1);
                    break;
                }
            }
        }
        if(flag)
            break;
        jo++;
    }
    if(!flag)
        printf("IMPOSSIBLE\n");
}

以下为Accepted代码

#include <cstdio>
#include <cstring>
#define Inf 0x3f3f3f3f

using namespace std;

struct node
{
    int x, y;
    int step;
} link_J[1040000], link_F[1040000], p, q;

int n, m, a, b, fo, ft, u[1004][1004];
bool v[1004][1004];
char st[1004][1004];
int jk[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

void BFS();
bool Judge(int dx, int dy);

int main()
{
    int T, i, j;
    scanf("%d", &T);
    while(T--)
    {
        fo = ft = 0;
        memset(v, true, sizeof(v));
        for(i = 0; i < n; i++){
            for(j = 0; j < m; j++){
                u[i][j] = Inf;
            }
        }

        scanf("%d %d", &n, &m);
        for(i = 0; i < n; i++){
            scanf("%s", st[i]);
            for(j = 0; j < m; j++){
                if(st[i][j] == 'F'){
                    v[i][j] = false;
                    u[i][j] = 0;
                    p.x = i, p.y = j, p.step = 0;
                    link_F[ft++] = p;
                }
                else if(st[i][j] == 'J'){
                    a = i, b = j;
                }
            }
        }
        BFS();
    }
    return 0;
}
bool Judge(int dx, int dy)
{
    if(dx < 0 || dx >= n || dy < 0 || dy >= m)
        return false;
    else
        return true;
}
void BFS()
{
    int jo, jt, i, flag;

    while(fo < ft)
    {
        p = link_F[fo];
        for(i = 0; i < 4; i++)
        {
            q.x = p.x + jk[i][0];
            q.y = p.y + jk[i][1];
            q.step = p.step + 1;
            if(Judge(q.x, q.y) && v[q.x][q.y] && st[q.x][q.y] != '#')
            {
                v[q.x][q.y] = false;
                u[q.x][q.y] = q.step;
                link_F[ft++] = q;
            }
        }
        fo++;
    }

    flag = 0, jo = jt = 0;;
    memset(v, true, sizeof(v));
    p.x = a;
    p.y = b;
    p.step = 0;
    if(p.x == 0 || p.x == n-1 || p.y == 0 || p.y == m-1)
    {
        flag = 1;
        printf("%d\n", p.step+1);
    }
    else if(p.step < u[p.x][p.y])
    {
        link_J[jt++] = p;
        v[p.x][p.y] = false;
    }

    while(jo < jt)
    {
        p = link_J[jo];
        for(i = 0; i < 4; i++)
        {
            q.x = p.x + jk[i][0];
            q.y = p.y + jk[i][1];
            q.step = p.step + 1;
            if(Judge(q.x, q.y) && v[q.x][q.y] && q.step < u[q.x][q.y] && st[q.x][q.y] != '#')
            {
                v[q.x][q.y] = false;
                link_J[jt++] = q;
                if(q.x == 0 || q.x == n-1 || q.y == 0 || q.y == m-1)
                {
                    flag = 1;
                    printf("%d\n", q.step+1);
                    break;
                }
            }
        }
        if(flag)
            break;
        jo++;
    }
    if(!flag)
        printf("IMPOSSIBLE\n");
}
UVA - 11624：Fire!
WINGREZ‘S BLOG
08-09 339
UVA-11624：Fire! 来源：UVA 标签： 参考资料： 相似题目： 题目 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 es...
UVA11624 Fire! 两次BFS 读懂题意很重要
colorfulshark
04-30 5927
Fire! Joe works in a maze. Unfortunately,portions of the maze have caught on fire, and the owner of the maze neglectedto create a fire escape plan. Help Joe escape the maze. Given Joe's location in
Fire! UVA - 11624
ln2037的博客
03-13 278
Fire! UVA - 11624 Joe works in a maze. Unfortunately, portions of the maze havecaught on re, and the owner of the maze neglected to create a reescape plan. Help Joe escape the maze.Given Joe’s loca...
Fire! UVA - 11624 两种方法
RUBGH的博客
01-06 225
两个队列的bfs 火势蔓延的地方joe不能走 一种方法是每次joe移动前将火势蔓延一次，另一种是将火势蔓延到某点的时间预处理出来，只要joe小于这个时间到达，就可以到达 1.题目有多个起火点 2.第二个方法有一个坑，需要将joe走过的标记，不然就会无限循环 #include<cstdio> #include<iostream> #include<map> #include<cstring> #include<queue> #include<s
UVa 11624 - Fire!
小白菜又菜
03-19 4732
题目：一个平面迷宫中有一个人，迷宫中有些点起火了，火和人每个单位时间只能向相邻的格子移动，             其中有一些空间被墙壁占据，问这个人在不背或烧到的情况下，离开迷宫的最快时间。 分析：搜索。迷宫中的最短路，首先就会想到bfs；并且bfs利用队列会使状态空间按时间顺序分层。             而火的扩散过程正好符合这个时间的层次。所以我们会想到，利用两个队列，一个储存人的
UVA - 11624 Fire!
那些年
02-27 1935
题意：求Joe走出迷宫的最短时间，有障碍，还有向四周蔓延的火 思路：将火的位置也加进BFS里面 #include #include #include #include #include using namespace std; const int MAXN = 1200; struct node{ int x,y,f,t; }; int dx[] ={1,-1,0,
UVA 11624 J - Fire!
@fei
12-12 268
原题： Joe works in a maze. Unfortunately, portions of the maze have caught on re, and the owner of the maze neglected to create a re escape plan. Help Joe escape the maze.Given Joe’s location in the maze and which squares of the maze are on re, you must
UVA - 11624 - Fire!
欢迎来到“曲终酣兴晚^R”的博客~
07-06 178
题目描述：题目描述：小明最后也没能进入游戏大厂，也没能娶到心爱的女孩，现在小明在一家迷宫里工作。不幸的是，迷宫里因为线路老化而发生了火灾。小明现在需要一个逃跑路线，请你帮助倒霉的小明从迷宫中逃离出去吧小明在迷宫中编号为 J 的位置，根据小明在迷宫中的位置以及迷宫中着火的位置（F），你必须确定在火焰烧到小明之前，他是否能逃离迷宫，如果能，他能多快逃离。小明每分钟移动一个方格（上、下、左、右四个方向中的一个），但是火焰一分钟能向四个方向同时蔓延。小明可以从迷宫的任何一个边界逃离。
UVA 11624 - Fire!
99度灰的博客
09-04 326
题目大意：J在着火的迷宫中，他每次能移动一步，火每次四周蔓延，人和或都不能到障碍物处。问他能否逃脱，逃脱的步数。 解题思路：刚开始是只有一个人的bfs，火的蔓延根据人的步数，每次计算，结果就tle了。后面看了题解的思路，bfs人和火，如果一个位置火比人早到或同时到，则，这点直接continue。因为可能有很多把火所以与人走迷宫的区别在于，当这点没走过或是，走过的步数比将要走到的步数长就替换。
UVA-11624-Fire!
weixin_62802134的博客
10-24 420
首先同一分钟，火往四周扩散，人四个方向选一个走一步，那么同一分钟人肯定不能走火这一分钟扩散的位置，这启发我们，对于每分钟先要有火扩散过的地图状态，以此来确定这一分钟人要怎么走。不妨认真思考一下，我们把找到扩散的火的位置更新入队，它的源头(即它是这个源头扩散出来的）就会出队，这样的话我们每次队里的元素个数就是本分钟需要处理的火源。一个迷宫着火了，火每分钟向四个方向扩散，人每分钟向四个方向的任意个方向走一步，人和火都不能碰到墙，问人能否逃出迷宫？（走出边界就算逃出迷宫）如果能，最快几分钟可以逃出。
UVA 11624 - Fire! - [BFS]
橘嘉禾
05-09 145
题目链接：https://cn.vjudge.net/problem/UVA-11624 题意： 给出一个 n×m 的矩阵，上面有的格子能走，有的格子是墙不能走。 有若干个点是火源，火每分钟都往上下左右蔓延一格（不能越墙）。又给出一个点是Joe的出发点，他只要能在不碰到火的前提下走出该矩阵，就算逃生成功，要求最小的逃生时间。 题解： 显然可以把火和人一起扔进队列里BFS，只要初始状态的时...
UVA11624-Fire!（BFS+预处理）
Stark_industry
03-07 254
题目链接：传送门Biubiubiu~~~ 吐槽一下这道题，做题体验极差，在uva转都转不了，在vjudge上也是要么提交失败要么就在队列中不动了，而且这题还挖了大坑，真的是折磨了我几天，打了几次，多少次过了样例就是不知道错哪里mdzz… 分析：题意大概是joe要逃离迷宫，同时迷宫着火，逃离成功的标志是Joe达到任意一条边界，而火焰回向四处燃烧并且持续不断向四周燃烧，这么一看就是两个BFS，然而却不...
UVa - 10278 Fire Station 消防站 图上的多源最短路径
灬豪侠彡
11-01 806
【问题描述】 某城市中有一些消防队。居民抱怨说一些房子离最近的消防站很远，所以必须建一个新的消防站。你要选择这个消防站的位置，让离最缺少服务的居民区最近。 这个城市有N个路口，用1..N编号，这N个路口被M条长度不同的双向道路连接。房子和消防站的位置都在路口上。假定在每个路口至少有一栋房子，且在同一个路口可以有多个消防站。【输入格式】 第一行包含三个整数：f,N,M，分别表示城市现有f个消防站
UVA-208 消防车 题解答案代码 算法竞赛入门经典第二版
最新发布
Coding home - 漂流瓶jz
09-07 350
这里有同学会问，遍历连通图也用的是DFS呀，为啥不会超时？因为我们要记录路径，所以DFS函数退出时要设置重新设置点为未访问过。但是连通图并不需要。所以连通图要快很多。另外题目的输出样例不对。看起来是%4d或者\t，但实际上就是普通的单个空格，甚至最前面不用空。直接用DFS遍历会超时。要先遍历一遍连通图，看看1和终点是否联通。一道不难的DFS题目。
B - Dungeon Master——广度优先搜索
BlessingXRY的博客
05-18 3081
Think: 1错误反思:已入队过结点不要忘记标记+数组不要越界 2知识点:广度优先搜索+队列B - Dungeon Master You are trapped in a 3D dungeon and need to find the quickest way out! The dungeon is composed of unit cubes which may or may no
列出连通集——DFS+BFS
BlessingXRY的博客
03-09 1864
think: 1深度优先搜索体现了递归的思想，广度优先搜索体现了队列的思想6 列出连通集 (25分)给定一个有NNN个顶点和EEE条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1N-1N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。输入格式: 输入第1行给出2个整数NNN(0
团战可以输、提莫必须死
BlessingXRY的博客
02-16 775
think: 1广度优先搜索+最值情况判断 2以结构体数组为基础的队列思想sdut原题链接团战可以输、提莫必须死 Time Limit: 1000MS Memory Limit: 65536KBProblem Description 为了一些你们不知道的原因,我们把LOL的地图抽象为一个n×m的矩阵 提莫积攒了k个蘑菇准备种到地图上去，因为提莫的背篓漏了，所
sdut ——找朋友（广度优先搜索）
BlessingXRY的博客
02-16 737
think: 1今天上午做了一上午才AC这个题目，感觉后台数据有非法输入，一开始自己用的int型map数组通过输入的字符的四种情况来判断map的值，可是样本数据正确提交却一直wrong answer,呃，感人的测试结果，刚才自己把猜测的非法数据解决方案输入了，还是wrong answer，看来应该是没有非法数据，这样的话错误应该还是在对应关系上不对，欲哭无泪状，刚才把字符串对应的换了对应关系，然后
数据结构实验之图论二：基于邻接表的广度优先搜索遍历
BlessingXRY的博客
02-15 699
think: 1基于邻接表的广度优先搜索遍历其实需要学会建立按照结点大小顺序建立的邻接表和广度优先搜索遍历的队列思想 2按照结点大小顺序建立的邻接表就是建立有序链表，在建立有序链表的过程中需要考虑头结点的数据存放，我直接把开始的结点放在头结点的数据域中，这样其实可以逐渐从一个点进行突破，后面可以讲数据域从一个数据扩展到另一个数据类型，相对其它模板，这样做减少了模板的通用性，但增加了模板的可塑性，
js-fire: 从JavaScript对象快速生成命令行界面
标题中提到的“js-fire”是一个JavaScript库，它的设计意图是对Google开发的Python库“python-fire”进行克隆。Google的python-fire是一个库，它能自动从Python对象生成命令行界面（CLI）。通过这样的自动化过程，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值