Dungeon Master题解bfs

已于 2023-05-15 16:06:24 修改
阅读量461 收藏 1
点赞数 1
分类专栏： 日拱一卒-acm 文章标签： 深度优先 算法 图论
于 2023-03-22 21:36:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51605778/article/details/129719948
版权

Dungeon Master

题面翻译

【题目描述】
这题是一个三维的迷宫题目，其中用‘.’表示空地，‘#’表示障碍物，‘S’表示起点，‘E’表示终点，求从起点到终点的最小移动次数，解法和二维的类似，只是在行动时除了东南西北移动外还多了上下。可以上下左右前后移动，每次都只能移到相邻的空位，每次需要花费一分钟，求从起点到终点最少要多久。

【输入】
多组测试数据。

一组测试测试数据表示一个三维迷宫：

前三个数，分别表示层数、一个面的长和宽，后面是每层的平面图。前三个数据为三个零表示结束。

【输出】
最小移动次数。

Translated by @剑圣夜雨声烦

题目描述

PDF

输入格式

输出格式

样例 #1

样例输入 #1

3 4 5
S....
.###.
.##..
###.#

#####
#####
##.##
##...

#####
#####
#.###
####E

1 3 3

S##
#E#
###

0 0 0

样例输出 #1

Escaped in 11 minute(s).
Trapped!

题解思路及TIME EXCEEDED问题

我最开始使用的方法和上一篇文章一样，采用的递归的思想，然而超时了……
所以转而使用循环来解决，超时的算法我就放在最后面了。
暴力搜索的循环写法可以类比图的bfs遍历搜索，使用一个队列来遍历整个图。每遍历到一个节点就把节点入队，遍历完队首所有邻接节点后队首出队。

题解


#include <cstdio>
#include <string.h>
#include <queue>
#include <limits.h>
using namespace std;

int l, r, c,mmin;
char map[50][50][50];
int vis[50][50][50];
typedef struct op
{
    int x;
    int y;
    int z;
    int step;
} point;

int judge(int x, int y ,int z)
{
    if (x < 0 || y < 0 || z < 0 || x >= l || y >= r || z >= c)
        return 0;
    if (map[x][y][z] == '#' || vis[x][y][z] == 1)
        return 0;
    return 1;
}

// 通过遍历矩阵来模拟移动，代码量很小
const int arrx[6] = {0, 0, 0, 0, 1, -1};
const int arry[6] = {0, 0, 1, -1, 0, 0};
const int arrz[6] = {1, -1, 0, 0, 0, 0};
void bfs(int x, int y, int z)
{
    queue<point> q;
    point buf;
    buf.x = x;
    buf.y = y;
    buf.z = z;
    buf.step = 0;
    q.push(buf);
    vis[x][y][z] = 1;
    while (!q.empty())
    {
        point cur = q.front();

        if (map[cur.x][cur.y][cur.z] == 'E')
        {
            if (cur.step < mmin)
            {
                mmin = cur.step;
            }
        }
        q.pop();
        //模拟移动，好好看好好学
        for (int i = 0; i < 6; i++)
        {
            int newx = cur.x + arrx[i];
            int newy = cur.y + arry[i];
            int newz = cur.z + arrz[i];
            if (judge(newx, newy, newz))
            {
                buf.x = newx;
                buf.y = newy;
                buf.z = newz;
                buf.step = cur.step + 1;
                vis[newx][newy][newz] = 1;
                q.push(buf);
            }
        }
    }

    return;
}
int main()
{

    while (scanf("%d %d %d", &l, &r, &c) && l != 0)
    {
        mmin = INT_MAX;
        point start;
        getchar();
        memset(vis, 0, sizeof(vis));
        for (int i = 0; i < l; i++)
        {
            if (i > 0)
                getchar();
            for (int j = 0; j < r; j++)
            {
                for (int k = 0; k < c; k++)
                {
                    scanf("%c", &map[i][j][k]);

                    if (map[i][j][k] == 'S')
                    {
                        start.x = i;
                        start.y = j;
                        start.z = k;
                    }
                    if (k == c - 1)
                    {
                        getchar();
                    }
                }
            }
        }
        // printf("********************\n");
        // for (int i = 0; i < l; i++)
        // {
        //     for (int j = 0; j < r; j++)
        //     {
        //         for (int k = 0; k < c; k++)
        //         {
        //             printf("%c ", map[i][j][k]);
        //             if (k == c - 1)
        //             {
        //                 printf("\n");
        //             }
        //         }
        //     }
        // }

        bfs(start.x, start.y, start.z);
        if (mmin == INT_MAX)
        {
            printf("Trapped!\n");
        }
        else
        {
            printf("Escaped in %d minute(s).\n", mmin);
        }
    }
    return 0;
}

超时题解（个人觉得没问题）

#include <cstdio>
#include <string.h>

#include <limits.h>
int count;
int l, r, c;
char map[50][50][50];
int
vis[50][50][50];
typedef struct op
{
    int x;
    int y;
    int z;
} point;
int max;
void dfs(int x, int y, int z)
{

    if (map[x][y][z] == 'E')
    {
        //        printf("i'm out!!\n");
        if (count < max && count != 0)
            max = count;
        return;
    }
    if (x - 1 >= 0)
    {
        if (map[x - 1][y][z] != '#' && vis[x - 1][y][z] == 0)
        {
            count++;
            vis[x][y][z] = 1;
            dfs(x - 1, y, z);
            vis[x][y][z] = 0;
            count--;
        }
    }
    if (y - 1 >= 0)
    {
        if (map[x][y - 1][z] != '#' && vis[x][y - 1][z] == 0)
        {
            count++;
            vis[x][y][z] = 1;
            dfs(x, y - 1, z);
            vis[x][y][z] = 0;
            count--;
        }
    }
    if (z - 1 >= 0)
    {
        if (map[x][y][z - 1] != '#' && vis[x][y][z - 1] == 0)
        {
            count++;
            vis[x][y][z] = 1;
            dfs(x, y, z - 1);
            vis[x][y][z] = 0;
            count--;
        }
    }
    if (x + 1 < l)
    {
        if (map[x + 1][y][z] != '#' && vis[x + 1][y][z] == 0)
        {
            count++;
            vis[x][y][z] = 1;
            dfs(x + 1, y, z);
            vis[x][y][z] = 0;
            count--;
        }
    }
    if (y + 1 < r)
    {
        char buf1 = map[x][y + 1][z];
        int buf2 = vis[x][y + 1][z];
        if (map[x][y + 1][z] != '#' && vis[x][y + 1][z] == 0)
        {
            count++;
            vis[x][y][z] = 1;
            dfs(x, y + 1, z);
            vis[x][y][z] = 0;
            count--;
        }
    }
    if (z + 1 < c)
    {
        if (map[x][y][z + 1] != '#' && vis[x][y][z + 1] == 0)
        {
            count++;
            vis[x][y][z] = 1;
            dfs(x, y, z + 1);
            vis[x][y][z] = 0;
            count--;
        }
    }
    return;
}
int main()
{

    while (scanf("%d %d %d", &l, &r, &c) && l != 0)
    {
        max = INT_MAX;
        point start;
        getchar();
        memset(vis, 0, sizeof(vis));
        for (int i = 0; i < l; i++)
        {
            if (i > 0)
                getchar();
            for (int j = 0; j < r; j++)
            {
                for (int k = 0; k < c; k++)
                {
                    scanf("%c", &map[i][j][k]);

                    if (map[i][j][k] == 'S')
                    {
                        start.x = i;
                        start.y = j;
                        start.z = k;
                    }
                    if (k == c - 1)
                    {
                        getchar();
                    }
                }
            }
        }
        //这是用来检查输入是否正确的
        // printf("********************\n");
        // for (int i = 0; i < l; i++)
        // {
        //     for (int j = 0; j < r; j++)
        //     {
        //         for (int k = 0; k < c; k++)
        //         {
        //             printf("%c ", map[i][j][k]);
        //             if (k == c - 1)
        //             {
        //                 printf("\n");
        //             }
        //         }
        //     }
        // }

        count = 0;
        dfs(start.x, start.y, start.z);
        if (max == INT_MAX)
        {
            printf("Trapped!\n");
        }
        else
        {
            printf("Escaped in %d minute(s).\n", max);
        }
    }
    return 0;
}
叔本华的尼采
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【poj 2251】 Dungeon Master 题意&题解&代码（C++）
曾经追梦的happy时光
03-22 1709
poj
poj-2251 Dungeon Master【bfs】
a915800048的专栏
03-30 1155
很基础的一道bfs /*这题是一个三维的迷宫题目，其中用'.'表示空地，'#'表示障碍物，'S'表示起点，'E'表示终点， 求从起点到终点的最小移动次数，解法和二维的类似， 只是在行动时除了东南西北移动外还多了上下。 对于题目给出数据的含义就是输入l，r，c，分别代表迷宫有l层，每层长宽分别是c，r。 对于数据以可以这样移动 (1,1,1)->(1,1,2)->(1,1,3)->(1,1,4)-
【bfs板子题】Dungeon Master poj-2251
m0_62951593的博客
05-12 91
一道广搜板子题，挂在这里方便复习 #include<cstdio> #include<iostream> #include<cmath> #include<vector> #include<map> #include<queue> #include<set> #include<iomanip> #include<cstring> #include<algorithm> #in.
信息学奥赛一本通 1248：Dungeon Master | OpenJudge NOI 2.5 1253:Dungeon Master
君义NOIP的博客
05-07 1788
【题目链接】 ybt 1248：Dungeon Master OpenJudge 2.5 1253:Dungeon Master 【题目翻译】 地牢城主 描述 你被困在一个3D地牢中，需要找到可以走出地牢的最快的一条路。地牢由方块单位组成，方块中可能有或没有填满岩石。向东、南、西、北、上或下移动一个单位需要花费1分钟。你不可以向对角线方向移动。整个迷宫外各个方向都被坚硬的岩石包围。 是否可能逃脱呢？如果可能，需要用多久？ 输入 输入包括一个地牢数字。每个地牢以包括L，R与C（大小都小于等于30）三个整数的一
信息学奥赛一本通（1248：Dungeon Master）
07-15 941
1248：Dungeon Master 时间限制: 1000 ms 内存限制: 65536 KB 提交数: 8637 通过数: 3432 【题目描述】 这题是一个三维的迷宫题目，其中用‘.’表示空地，‘#’表示障碍物，‘S’表示起点，‘E’表示终点，求从起点到终点的最小移动次数，解法和二维的类似，只是在行动时除了东南西北移动外还多了上下。可以上下左右前后移动，每次都只能移到相邻的空位，每次需要花费一分钟，求从起点到终点最少要多久。 【输入】 多组测试数据。 一组测...
POJ2251-Dungeon Master
07-31
【标题】"POJ2251-Dungeon Master" 是一个来自北京大学在线判题系统POJ（Problem Set）的编程题目。这个题目属于算法竞赛的一部分，挑战者需要编写程序来解决特定的问题，以提高自己的编程能力和算法理解。 【描述...
Dungeon Master DS-开源
04-26
【Dungeon Master DS-开源】项目是一个专门为Nintendo DS游戏设备设计的开源移植版本，它使得经典的游戏Dungeon Master以及其续作能在NDS平台上运行。这个项目的核心目标是将原版游戏的体验完整地转移到掌上设备，...
Dungeon Master Ruler-开源
04-26
在丰富的角色扮演游戏(RPG)世界中，地下城主(Dungeon Master, DM)是故事的编织者，他们构建世界观、设定规则、设计冒险情节，引领玩家探索未知的奇幻领域。而DM Ruler正是一款专为地下城主打造的开源工具，旨在帮助...
Dungeon Master Helper-开源
04-27
Java应用程序，旨在在针对PDA的AD＆D游戏会话中帮助地牢主
Open Dungeon Master Tools-开源
04-27
《Open Dungeon Master Tools——探索开源世界的奇幻冒险》 在广袤的数字世界中，有一类特殊的工具，它们专为地牢大师（Dungeon Master）设计，致力于减轻他们在构建和管理角色扮演游戏（Role-Playing Game，简称...
【广搜】poj2151——Dungeon Master
ChangeW fafa的博客
10-14 138
题目大意 三维的迷宫题目，其中用‘.’表示空地，‘#’表示障碍物，‘S’表示起点，‘E’表示终点，求从起点到终点的最小移动次数。 广搜——与二维广搜相似，只不过换为三维：6个方向 map[][][]来标记 路障，起点s，终点e。 v[][][]，三维标记数组 使用队列 易错点： （卡了好久找不到原因——浪费好长时间。） main()输入map[][][]，x-l ,y-r ,z-c 与 dfs...
poj 2251 Dungeon Master
zoro_n的博客
12-22 245
点击打开链接 题意： 给一个立体的迷宫，问能否走出来，能的话输出最短时间。 题解：一个三维的迷宫， 走的方向无非和二维差别就是多了上下两个方向，直接广搜跑一边就行了。 //#include #include #include #include #define LL long long using namespace std; const int maxn=
UVA - 532 Dungeon Master
静静地码
10-19 719
题目大意：给你一个三维迷宫，起点是“S”，终点是“R”，
BFS简单题记
weixin_30315723的博客
12-10 243
围成面积 链接：http://ybt.ssoier.cn:8088/problem_show.php?pid=1359时间限制: 1000 ms 内存限制: 65536 KB 【题目描述】 编程计算由“*”号围成的下列图形的面积。面积计算方法是统计*号所围成的闭合曲线中水平线和垂直线交点的数目。如下图所示，在10*10的二维数组中，有“*”围住了15个点，因此面积为15...
信息奥赛一本通1248：Dungeon Master
mengdicfm的博客
07-17 1284
【题目描述】 这题是一个三维的迷宫题目，其中用‘.’表示空地，‘#’表示障碍物，‘S’表示起点，‘E’表示终点，求从起点到终点的最小移动次数，解法和二维的类似，只是在行动时除了东南西北移动外还多了上下。可以上下左右前后移动，每次都只能移到相邻的空位，每次需要花费一分钟，求从起点到终点最少要多久。 【输入】 多组测试数据。 一组测试测试数据表示一个三维迷宫： 前三个数，分别表示层数、一个面的长和宽，...
Dungeon Master 简单搜索
CHEN_XU_LING的博客
09-27 139
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 not be filled with rock. It takes one minute to move one unit north, south, east, west, up or down. You cannot move
1248：Dungeon Master
zqhf123的博客
02-14 294
1248：Dungeon Master 时间限制: 1000 ms 内存限制: 65536 KB 提交数: 4941 通过数: 2006 【题目描述】 这题是一个三维的迷宫题目，其中用‘.’表示空地，‘#’表示障碍物，‘S’表示起点，‘E’表示终点，求从起点到终点的最小移动次数，解法和二维的类似，只是在行动时除了东南西北移动外还多了上下。可以上下左右前后移动，每次都只能移到...
ACM 算法3-3 迷宫 程序
Procher的专栏
03-29 1854
有一个 10 x 10 的迷宫，起点是‘S’，终点是‘E’，墙是‘#’，道路是空格。一个机器人从起点走到终点。当机器人走到一个通道块，前面已经没有路可走时，它会转向到当前面向的右手方向继续走。如果机器人能够过，则留下足迹‘*’，如果走不通，则留下标记‘!’。 下面给出书中的算法，请你模拟机器人的走法输出最终的状态。
dungeon master
最新发布
05-27
Dungeon Master（地牢主）是一个角色扮演游戏（RPG）中的术语，通常指的是扮演游戏中的主持人或者游戏主理人。Dungeon Master负责创造游戏中的世界，包括故事情节、地图、场景、任务、怪物等等。在游戏中，玩家扮演...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值