POJ3984&&HDU1180,广度搜索BFS？acm新手成长之路

最新推荐文章于 2021-08-24 17:24:04 发布
最新推荐文章于 2021-08-24 17:24:04 发布
阅读量418 收藏 4
点赞数 2
分类专栏： poj HDU BFS 文章标签： HDU poj bfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csl784513390/article/details/76285436
版权
poj 同时被 3 个专栏收录
4 篇文章 0 订阅
订阅专栏
HDU
4 篇文章 0 订阅
订阅专栏
BFS
1 篇文章 0 订阅
订阅专栏

POJ3984和HDU1180：《广度搜索（BFS）》迷宫问题

广度搜索和深度搜索（dfs）

先普及一波广度搜索和深度搜索的概念：
这里写图片描述
如图，我们要从上往下搜索树的每个节点，用深度搜索，每个节点搜到的先后顺序如图，如果用广度搜索，搜到的节点顺序将是1-2-7-8-3-6-9-12-4-5-10-11。深度搜索优先搜索到最深层，到尽头在往分支搜索，一般使用递归或者栈来实现。广度搜索则是一层一层的搜到底。一般用队列来实现。
今天两题都是用bfs来做（这几天都有多校的比赛没时间找dfs的题目，抱歉了各位），先看POJ3984

poj3984

定义一个二维数组：
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 0, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线
Input
一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。
Output
左上角到右下角的最短路径，格式如样例所示。
Sample Input
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
Sample Output
(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)
题意都清楚了,这题明显的bfs模板题，只是记录路线有点麻烦，可以将每个格子标号，在记录走到这个格子的前一格子的编号即可。

#include<string.h>
#include<iostream>
#include<cstdio>
#include<queue>   //队列
using namespace std;
int map1[5][5];
      //迷宫地图
int vis[5][5];
     //判断格子是否走过，避免重复，0表示没走过
struct Node
{
    int x,y;
    int pre;    //记录前一个格子的编号，方便输出。
}node[30];
int to[2][4]={1,0,-1,0,0,1,0,-1};
bool judge(int x,int y)
 //判断格子是否为可到达
{
    if(x>=0&&y>=0&&x<5&&y<5&&map1[x][y]==0)
        return 1;
    else
        return 0;
}
queue<Node> Q;
void bfs()
{    node[0].pre=-1;
     //起点的前一个格子标记为-1
    Q.push(node[0]);
    Node a;
    vis[0][0]=1;
    int x1,y1,num;
    while(!Q.empty())
    {
        a=Q.front();
        Q.pop();
     //删除队列头元素
        for(int i=0;i<4;i++)
 //每个格子有4个方向可以移动
        {
            x1=a.x+to[0][i];
            y1=a.y+to[1][i];
            num=x1*5+y1;
   //将横纵坐标转化为格子编号，方便记录
            if(judge(x1,y1)&&!vis[x1][y1])
            {   vis[x1][y1]=1;
         //避免重复
               node[num].pre=a.x*5+a.y;  //记录前一个格子编号
               if(x1==4&&y1==4)
                  return ;
 //到达终点
               Q.push(node[num]);
            }
        }
    }
}
void print(int x)//递归输出
{
    int t=node[x].pre;
    if(t==-1)

        {
            printf("(%d, %d)\n",node[0].x,node[0].y);
           return ;
      }
    else
    {
        print(t);
    }
        printf("(%d, %d)\n",node[x].x,node[x].y);
}
int main()
{
    int cnt=0;
    memset(vis,0,sizeof(vis));
    for(int i=0;i<5;i++)
    {
        for(int j=0;j<5;j++)
        {
            scanf("%d",&map1[i][j]);
            node[cnt].x=i;node[cnt++].y=j;
        }
    }
    bfs();
    print(24);
    return 0;
}

HDU1180这题也和上题一样是模板题，只是这题多了个梯子的判断

Hogwarts正式开学以后,Harry发现在Hogwarts里,某些楼梯并不是静止不动的，相反,他们每隔一分钟就变动一次方向.
比如下面的例子里,一开始楼梯在竖直方向,一分钟以后它移动到了水平方向,再过一分钟它又回到了竖直方向.Harry发现对他来说很难找到能使得他最快到达目的地的路线,这时Ron(Harry最好的朋友)告诉Harry正好有一个魔法道具可以帮助他寻找这样的路线,而那个魔法道具上的咒语,正是由你纂写的.
Input
测试数据有多组，每组的表述如下：
第一行有两个数,M和N,接下来是一个M行N列的地图,’*’表示障碍物,’.’表示走廊,’|’或者’-‘表示一个楼梯,并且标明了它在一开始时所处的位置:’|’表示的楼梯在最开始是竖直方向,’-‘表示的楼梯在一开始是水平方向.地图中还有一个’S’是起点,’T’是目标,0<=M,N<=20,地图中不会出现两个相连的梯子.Harry每秒只能停留在’.’或’S’和’T’所标记的格子内.
Output
只有一行,包含一个数T,表示到达目标的最短时间.
注意:Harry只能每次走到相邻的格子而不能斜走,每移动一次恰好为一分钟,并且H子而不能斜走,每移动一次恰好为一分钟,并且Harry登上楼梯并经过楼梯到达对面的整个过程只需要一分钟,Harry从来不在楼梯上停留.并且每次楼梯都恰好在Harry移动完毕以后才改变方向.
Sample Input
5 5
**..T
* * .*.
..|..
..*..
S….
这里写图片描述（字符间没空格）

//HDU1180;
#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;
const int INF=100000;
int n,m;
struct Node
{
    int x,y;
    int step;
   //走到该格子需要的步数
}node[401];
char map1[21][21];
queue<Node> Q;
bool judge(int x,int y)  //判断格子是否能进入
{
    if(x>=0&&y>=0&&x<n&&y<m&&map1[x][y]!='*')
        return 1;
    else
        return 0;
}
int to[2][4]={1,0,-1,0,0,1,0,-1};
void bfs()
{
    Node a;
    while(!Q.empty())
    {
        a=Q.front();
        Q.pop();
        for(int i=0;i<4;i++)
        {
            int x1=a.x+to[0][i];
            int y1=a.y+to[1][i];
            int num=x1*m+y1;
            if(judge(x1,y1))
            {
                if((map1[x1][y1]=='.'||map1[x1][y1]=='T')&&node[num].step>a.step+1)
//这里判断>a.step+1才更新表示当前路线比之前的快，若是慢就没必要更了
                {   node[num].step=a.step+1;
                    Q.push(node[num]);
                }
                else if(map1[x1][y1]=='|'&&a.step%2==0)/*模2等于0表示梯子方向和初始方向一致*/
                {     num+=(to[0][i]*m+to[1][i]);
  //不会在梯子上停留，所以再向前走一格
                    if((i==0||i==2)&&node[num].step>a.step+1)
                    {
                        node[num].step=a.step+1;
                        Q.push(node[num]);
                    }
                    else if((i==1||i==3)&&node[num].step>a.step+2)
                    {
                        node[num].step=a.step+2;
                        Q.push(node[num]);
                    }
                }
                else if(map1[x1][y1]=='|'&&a.step%2==1)
                {      num+=(to[0][i]*m+to[1][i]);
                     if((i==0||i==2)&&node[num].step>a.step+2)
                    {
                        node[num].step=a.step+2;
                        Q.push(node[num]);
                    }
                    else if((i==1||i==3)&&node[num].step>a.step+1)
                    {
                        node[num].step=a.step+1;
                        Q.push(node[num]);
                    }
                }
                else if(map1[x1][y1]=='-'&&a.step%2==1)
                {    num+=(to[0][i]*m+to[1][i]);
                    if((i==0||i==2)&&node[num].step>a.step+1)
                    {
                        node[num].step=a.step+1;
                        Q.push(node[num]);
                    }
                    else if((i==1||i==3)&&node[num].step>a.step+2)
                    {
                        node[num].step=a.step+2;
                        Q.push(node[num]);
                    }
                }
                else if(map1[x1][y1]=='-'&&a.step%2==0)
                {       num+=(to[0][i]*m+to[1][i]);
                     if((i==0||i==2)&&node[num].step>a.step+2)
                    {
                        node[num].step=a.step+2;
                        Q.push(node[num]);
                    }
                    else if((i==1||i==3)&&node[num].step>a.step+1)
                    {
                        node[num].step=a.step+1;
                        Q.push(node[num]);
                    }
                }
            }
        }
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {    int cnt=0;
         int S,T;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                cin>>map1[i][j];
                node[cnt].x=i;node[cnt].y=j;
                 node[cnt++].step=INF;  //初始化为最大值
                 if(map1[i][j]=='S')
                    {
                        S=cnt-1;
    //记录起点的位置
                        node[S].step=0;
                    }
                if(map1[i][j]=='T')
                {
                    T=cnt-1;
    //终点位置
                }
            }
        }
        Q.push(node[S]);
        bfs();
        printf("%d\n",node[T].step);
    }return 0;
}

今天的题是不是so easy？我的前几篇博客会先写寒假训练的基础内容，也是方便各位新手学习（现在学的太难我也做不出，要不也不会多校的时候才A两题）。这些博客见证了我acm新手的成长之路，大家有什么好的算法解法可以留言相互学习。

前端练习生
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
acm程序设计竞赛广度搜索BFS实例
08-21
本人自己总结的acm广度搜索实例代码，经典的几个代码程序 只有代码，没有题目，主要是在POJ的。我是在ubuntu下压缩的。
HDU 1180 诡异的楼梯 (DFS)
Ⅶ的专栏
08-03 1115
HDU 1180 诡异的楼梯 (DFS)
POJ3984 迷宫问题【BFS】
海岛Blog
07-11 5291
  迷宫问题 Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 25795   Accepted: 15019   Description 定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0...
C - 迷宫问题 POJ - 3984
EnochChen_的博客
08-24 132
Description 定义一个二维数组：int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, };它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 Input 一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。 Output 左上角到右下角的
POJ-3984-迷宫问题
fuerbosi
07-12 163
POJ-3984-迷宫问题 http://poj.org/problem?id=3984 用BFS求最短路劲，记录每一个状态之前的状态，输出路劲即可 #include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;stdlib.h&gt; int map[5][5]; int visit[5][5]; int pre[100]; ...
HDU 3984 迷宫问题
扬帆起航
03-20 1192
定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 Input 一个5
ACM.zip_ACM_poj_poj3187_poj3669
09-23
poj两道题的c++实现。已经测试过可以通过oj
acm新手刷题攻略之poj
11-02
acm新手刷题攻略之poj，详细介绍了poj入门必做题目的分类与推荐，
HDU&&POJ图论题集
04-24
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个...
POJ 3984迷宫问题(输出路径)
Ordinarv
08-27 286
题目大意 给你一个5*5的迷宫，0代表通路，1代表墙，找到从迷宫左上角到达右下角的最短路径，并输出路径。 思路 与其他直接输出最短路径的长度不同的是，这道题要求输出最短路径。要输出这个路径，所以就要考虑状态了，每一个状态都应该存储到达这个状态的路径。 对于我来说第一次做这种题难点在于如何存储路径，有两种类似的方法，一种是记录每次通过dx、dy数组移动的i值，二是直接把x、y放入队列中，最后...
HDU1049
code
02-14 1487
HDU1049 Climbing Worm 一只蠕虫在深n英寸的井中，它每分钟会向上爬u英寸，然后它会休息1分钟并且下滑d英寸，现在要求它要多少分钟能到达进口（它就算刚到井口然后会下滑，也算它到达井口）。我们把不足1分钟的时间也算是1分钟。 输入：包含多组实例。每行代表一个实例，包括3个正整数，n，u 和 d。d 输出：对于每个实例，输出蠕虫爬到井口所需要的整数分钟时间。 分析：蠕虫到达
HDOJ 1180 诡异的楼梯 DFS
R_xiaozhu_Q的专栏
05-30 1126
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1180 用DFS很容易超时，尽管题中已经考虑了剪枝，还是超了 1000MS，这题有BFS的高效解法，不过感觉时间限制太小了，1000MS就超了，上次做的题，用BFS 2000MS还能 AC啊，先上代码，思路：重点考虑到达楼梯周围四个点时候的楼梯方向和四个位置，依次枚举。 #include #
POJ - 3984 迷宫问题的详解
一只特立独行的猫的博客
05-11 552
是
99-智慧园区数据平台方案.pptx
04-27
99-智慧园区数据平台方案.pptx
node-v12.11.1-x86.msi
最新发布
04-27
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于Springboot+Vue华强北商城二手手机管理系统-毕业源码案例设计.zip
04-27
网络技术和计算机技术发展至今，已经拥有了深厚的理论基础，并在现实中进行了充分运用，尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代，所以对于信息的宣传和管理就很关键。系统化是必要的，设计网上系统不仅会节约人力和管理成本，还会安全保存庞大的数据量，对于信息的维护和检索也不需要花费很多时间，非常的便利。 网上系统是在MySQL中建立数据表保存信息，运用SpringBoot框架和Java语言编写。并按照软件设计开发流程进行设计实现。系统具备友好性且功能完善。 网上系统在让售信息规范化的同时，也能及时通过数据输入的有效性规则检测出错误数据，让数据的录入达到准确性的目的，进而提升数据的可靠性，让系统数据的错误率降至最低。 关键词：vue；MySQL；SpringBoot框架 【引流】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
Excel模版：工资条模板
04-27
Excel工资条模板是一种预先设计好的电子表格文件，主要用于生成和打印员工的工资单，让员工清楚了解自己的工资组成和扣款详情。模板通常包含了以下几个关键部分： 1. **员工信息区**： - 姓名 - 员工编号/工号 - 部门 - 职位 2. **工资构成区**： - 基本工资 - 岗位工资 - 绩效奖金 - 加班工资 - 其他补贴（如交通补贴、餐补、全勤奖等） - 各项津贴（如高温补贴、取暖费等） - 其他应发收入（如年终奖、提成、福利等） 3. **扣款项目区**： - 社保扣款（养老保险、医疗保险、失业保险、工伤保险、生育保险） - 住房公积金 - 个人所得税 - 其他扣款（如迟到、旷工、违规罚款等） - 预借还款（如有） 4. **工资结算区**： - 应发工资总额 - 扣款总额 - 实发工资 5. **备注栏**： - 用于标注本月工资的特殊情况说明，如请假、调休、加班等情况。 6. **签名栏**： - 供员工确认工资数额无误后签名，也可以
POJ3984—迷宫问题java
11-02
根据提供的引用内容，可以得知这是一道关于迷宫问题的题目，需要使用Java语言进行编写。具体来说，这道题目需要实现一个迷宫的搜索算法，找到从起点到终点的最短路径。可以使用广度优先搜索或者深度优先搜索算法来解决这个问题。 下面是一个使用广度优先搜索算法的Java代码示例： ```java import java.util.*; public class Main { static int[][] maze = new int[5][5]; // 迷宫地图 static int[][] dir = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}}; // 方向数组 static boolean[][] vis = new boolean[5][5]; // 标记数组 static int[][] pre = new int[5][5]; // 记录路径 public static void main(String[] args) { Scanner sc = new Scanner(System.in); for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { maze[i][j] = sc.nextInt(); } } bfs(0, 0); Stack<Integer> stack = new Stack<>(); int x = 4, y = 4; while (x != 0 || y != 0) { stack.push(x * 5 + y); int t = pre[x][y]; x = t / 5; y = t % 5; } stack.push(0); while (!stack.empty()) { System.out.print(stack.pop() + " "); } } static void bfs(int x, int y) { Queue<Integer> qx = new LinkedList<>(); Queue<Integer> qy = new LinkedList<>(); qx.offer(x); qy.offer(y); vis[x][y] = true; while (!qx.isEmpty()) { int tx = qx.poll(); int ty = qy.poll(); if (tx == 4 && ty == 4) { return; } for (int i = 0; i < 4; i++) { int nx = tx + dir[i][0]; int ny = ty + dir[i][1]; if (nx >= 0 && nx < 5 && ny >= 0 && ny < 5 && maze[nx][ny] == 0 && !vis[nx][ny]) { vis[nx][ny] = true; pre[nx][ny] = tx * 5 + ty; qx.offer(nx); qy.offer(ny); } } } } } ``` 该代码使用了广度优先搜索算法，首先读入迷宫地图，然后从起点开始进行搜索，直到找到终点为止。在搜索的过程中，使用标记数组记录已经访问过的位置，使用路径数组记录路径。最后，使用栈来输出路径。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值