栈与队列的应用——深度、广度优先搜索迷宫出口

最新推荐文章于 2024-09-26 16:50:25 发布
最新推荐文章于 2024-09-26 16:50:25 发布
阅读量110 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/epsilon/archive/2013/01/13/2858944.html
版权

今天，寒假第2天。

今天看的是栈与队列。课本上关于栈，列举了一些应用实例。其中一个就是关于迷宫出口的搜索问题。想起之前在刘汝佳的《算法竞赛入门经典》上的关于这个问题的深度优先方法。通过深度优先方法，可以求出最短的走出迷宫的路径，其基本思想是：将整个迷宫地图视为一棵二叉树，其中在迷宫中先走到的地方视为它所能及地方的双亲节点，于是：迷宫的起始点可视为根节点，与迷宫一步之遥的所有节点都可视为根节点的孩子节点，与孩子节点一步之遥的又可视为孩子的孩子节点...依此类推。当然，我们还需要一个数组记录已经走过的节点，这些节点是不需再走第二次的，如果经过这些节点能到达终点，走一次就够了，何况先前“抢占”该节点的路径一定能更先到达终点。

如果利用栈的方式，则是“一条路走到黑”，要么走到了终点，要么走到死胡同再折返回来。这种方式同样需要记录已走过的节点，以免浪费不必要的时间。

这两种方法实现起来都不太难，基本思路就是BFS(广度优先)和DFS(深度优先)的基本思路。关于最后输出的问题，如果用DFS，只需用一个数组，走一步标记一下，返一步在标记回来，这样最后就能得到结果了；如果用BFS会稍微复杂一些，因为这种方式是“齐头并进”，大家一起一步一步往前走，很难做标记。因此在走的过程中，要用一个数组，能体现出后面经过的节点与它之前节点之间的关系，一种具体方法是：在arr[x][y]中存放走到坐标(x,y)的前一步的坐标。这样顺着出口往回找，最终一定能找到入口。

运行结果如下：（图一）基于栈的DFS，（图二）基于队列的BFS。两者结果不同，其中BFS的是最短路径。

图一 DFS  图二 BFS

View Code 
  1 /*
  2     功能：
  3         使用栈，实现对于迷宫的广度优先搜索。
  4     输入：
  5         无
  6     输出：
  7         迷宫图形
  8     FINISHED DATE:
  9         2013.1.13 
 10 */
 11 #include <stdio.h>
 12 #include <stdlib.h>
 13 #include <string.h>
 14 //define size value
 15 #define MAXWIDTH 5
 16 #define MAXLENGTH 8
 17 #define STACKSIZE 100
 18 //define return value
 19 #define ERROR 0
 20 #define OK 1
 21 #define OVERFLOW 0
 22 typedef struct {
 23     int x,y;
 24 }Pos;
 25 typedef struct {
 26     Pos *base,*top;
 27     int stack_size;
 28 }Stack;
 29 bool StackEmpty(Stack s) {
 30     return (s.top == s.base);
 31 }
 32 int StackPop(Stack &s,Pos &p,bool isPop)
 33 {
 34     if(s.base == s.top)
 35         return ERROR;
 36     p.x = (s.top-1)->x;
 37     p.y = (s.top-1)->y;
 38     if(isPop) s.top--;
 39     return OK;
 40 }
 41 int StackPush(Stack &s,Pos p)
 42 {
 43     if(s.top-s.base >= s.stack_size)
 44         return ERROR;    
 45     s.top->x = p.x;
 46     s.top->y = p.y;
 47     s.top++;
 48     return OK;
 49 }
 50 int InitStack(Stack &s)
 51 {
 52     s.base = s.top = (Pos *)malloc(sizeof(Pos)*STACKSIZE);
 53     if(!s.base) return OVERFLOW;
 54     s.stack_size = STACKSIZE;
 55     return OK;
 56 }
 57 void FindPath(int Maze[MAXWIDTH][MAXLENGTH],Pos des)
 58 {
 59     Stack s;Pos pos;    
 60     int footprint[MAXWIDTH][MAXLENGTH]={0},res[MAXWIDTH][MAXLENGTH]={0};
 61     InitStack(s);    
 62     pos.x = pos.y = 0;//起始点为(0,0)
 63     StackPush(s,pos);
 64     footprint[0][0] = res[0][0] = 1;
 65     while(!StackEmpty(s)) {
 66         StackPop(s,pos,false);
 67         if(pos.x == des.x && pos.y == des.y)
 68             break;
 69         if(pos.y+1 < MAXLENGTH && !footprint[pos.x][pos.y+1] && !Maze[pos.x][pos.y+1]) {
 70             footprint[pos.x][pos.y+1] = res[pos.x][pos.y+1] = 1;
 71             pos.y++;
 72             StackPush(s,pos);
 73         }
 74         else if(pos.x+1 < MAXWIDTH && !footprint[pos.x+1][pos.y] && !Maze[pos.x+1][pos.y]) {
 75             footprint[pos.x+1][pos.y] =res[pos.x+1][pos.y] = 1;
 76             pos.x++;
 77             StackPush(s,pos);
 78         }
 79         else if(pos.y-1 >= 0 && !footprint[pos.x][pos.y-1] && !Maze[pos.x][pos.y-1]) {
 80             footprint[pos.x][pos.y-1] = res[pos.x][pos.y-1] = 1;
 81             pos.y--;
 82             StackPush(s,pos);
 83         }
 84         else if(pos.x-1 >= 0 && !footprint[pos.x-1][pos.y] && !Maze[pos.x-1][pos.y]) {
 85             footprint[pos.x-1][pos.y] = res[pos.x-1][pos.y] = 1;
 86             pos.x--;
 87             StackPush(s,pos);
 88         }
 89         else {
 90             StackPop(s,pos,true);
 91             res[pos.x][pos.y] = 0;
 92         }
 93     }
 94     if(!StackEmpty(s)) {    
 95     //have found the path
 96         printf("  ");
 97         for(int j = 0;j<MAXLENGTH;++j) 
 98             printf("%d ",j);
 99         printf("\n");
100         for(int i = 0;i<MAXWIDTH;++i) {
101             printf("%d ",i);
102             for(int j = 0;j<MAXLENGTH;++j) {
103                 if(res[i][j]) {
104                     printf("※");
105                 }
106                 else if(Maze[i][j]) printf("■");
107                 else printf("  ");
108             }
109             printf("\n");
110         }
111     }
112     else printf("No path found!\n");
113 }
114 int main()
115 {
116     int Maze[MAXWIDTH][MAXLENGTH] = {{0,0,0,0,1,1,1,0},{0,1,0,1,0,0,0,0},{0,1,0,0,0,1,1,0},{0,0,0,1,1,1,0,0},{1,1,0,0,0,0,0,0}};
117     Pos des;
118     des.x = 4;des.y = 7;
119     FindPath(Maze,des);
120     system("pause");
121     return 0; 
122 }

 

View Code 
  1 /*
  2     功能：
  3         使用队列，实现对于迷宫的深度优先搜索。找到最短路径。 
  4     输入：
  5         无
  6     输出：
  7         迷宫图形
  8     FINISHED DATE:
  9         2013.1.13 
 10 */
 11 #include <stdio.h>
 12 #include <stdlib.h>
 13 #include <string.h>
 14 //define size value
 15 #define MAXWIDTH 5
 16 #define MAXLENGTH 8
 17 #define MAXSIZE 5000
 18 //define return value
 19 #define ERROR 0
 20 #define OK 1
 21 #define OVERFLOW 0
 22 typedef struct {
 23     int x,y;
 24 }Pos;
 25 typedef struct {
 26     Pos *base;
 27     int front,rear;
 28     int queue_size;
 29 }Queue; 
 30 int InitQueue(Queue &q)
 31 {
 32     q.base = (Pos*)malloc(sizeof(Pos)*MAXSIZE);
 33     q.front = q.rear = 0;
 34     q.queue_size = MAXSIZE;
 35     return OK;
 36 }
 37 int QueuePush(Queue &q,Pos pos)
 38 {
 39     //Queue is full
 40     if((q.rear+1)%q.queue_size==q.front) {
 41         return ERROR;
 42     }
 43     q.base[q.rear].x = pos.x;
 44     q.base[q.rear].y = pos.y;
 45     q.rear = (q.rear+1)%q.queue_size;
 46     return OK;
 47 }
 48 int QueuePop(Queue &q,Pos &pos,bool isPop)
 49 {
 50     //queue is empty
 51     if(q.front==q.rear) {
 52         return ERROR;
 53     }
 54     pos.x = q.base[q.front].x;
 55     pos.y = q.base[q.front].y;
 56     if(isPop) q.front = (q.front+1)%q.queue_size;
 57     return OK;
 58 }
 59 bool QueueEmpty(Queue q)
 60 {
 61     return (q.rear==q.front);
 62 }
 63 void FindPath(int Maze[MAXWIDTH][MAXLENGTH],Pos des)
 64 {
 65     Queue q;Pos pos,tmp;
 66     int footprint[MAXWIDTH][MAXLENGTH]={0};
 67     Pos res[MAXWIDTH][MAXLENGTH];
 68     InitQueue(q);
 69     pos.x = 0;pos.y = 0;
 70     QueuePush(q,pos);
 71     while(!QueueEmpty(q)){
 72         QueuePop(q,pos,1);
 73         if(pos.x == des.x && pos.y == des.y)
 74             break;
 75         if(pos.y+1 < MAXLENGTH && !footprint[pos.x][pos.y+1] && !Maze[pos.x][pos.y+1]) {
 76             footprint[pos.x][pos.y+1] = 1;
 77             res[pos.x][pos.y+1].x = pos.x;
 78             res[pos.x][pos.y+1].y = pos.y;
 79             tmp.x = pos.x;
 80             tmp.y = pos.y+1;
 81             QueuePush(q,tmp);
 82         }
 83         if(pos.x+1 < MAXWIDTH && !footprint[pos.x+1][pos.y] && !Maze[pos.x+1][pos.y]) {
 84             footprint[pos.x+1][pos.y] = 1;
 85             res[pos.x+1][pos.y].x = pos.x;
 86             res[pos.x+1][pos.y].y = pos.y;
 87             tmp.x = pos.x+1;
 88             tmp.y = pos.y;
 89             QueuePush(q,tmp);
 90         }
 91         if(pos.y-1 >= 0 && !footprint[pos.x][pos.y-1] && !Maze[pos.x][pos.y-1]) {
 92             footprint[pos.x][pos.y-1] = 1;
 93             res[pos.x][pos.y-1].x = pos.x;
 94             res[pos.x][pos.y-1].y = pos.y;
 95             tmp.x = pos.x;
 96             tmp.y = pos.y-1;
 97             QueuePush(q,tmp);
 98         }
 99         if(pos.x-1 >= 0 && !footprint[pos.x-1][pos.y] && !Maze[pos.x-1][pos.y]) {
100             footprint[pos.x-1][pos.y] = 1;
101             res[pos.x-1][pos.y].x = pos.x;
102             res[pos.x-1][pos.y].y = pos.y;
103             tmp.x = pos.x-1;
104             tmp.y = pos.y;
105             QueuePush(q,tmp);
106         }
107     }
108     if(!QueueEmpty(q)) {
109     //have found the path    
110         int x,y,tx;
111         x = des.x;
112         y = des.y;
113         memset(footprint,0,MAXWIDTH*MAXLENGTH*sizeof(int));
114         while(x!=0||y!=0) {    
115             footprint[x][y] = 1;
116             tx = res[x][y].x;
117             y = res[x][y].y;
118             x = tx;
119         }
120         footprint[x][y] = 1;
121         printf("  ");
122         for(int j = 0;j<MAXLENGTH;++j) 
123             printf("%d ",j);
124         printf("\n");
125         for(int i = 0;i<MAXWIDTH;++i) {
126             printf("%d ",i);
127             for(int j = 0;j<MAXLENGTH;++j) {
128                 if(footprint[i][j]) {
129                     printf("※");
130                 }
131                 else if(Maze[i][j]) printf("■");
132                 else printf("  ");
133             }
134             printf("\n");
135         }
136     }
137     else printf("No path found!\n");
138     
139 }
140 int main()
141 {
142     int Maze[MAXWIDTH][MAXLENGTH] = {{0,0,0,0,1,1,1,0},{0,1,0,1,0,0,0,0},{0,1,0,0,0,1,1,0},{0,0,0,1,1,1,0,0},{1,1,0,0,0,0,0,0}};
143     Pos des;
144     des.x = 4;des.y = 7;
145     FindPath(Maze,des);
146     system("pause");
147     return 0; 
148 }

 

 

转载于:https://www.cnblogs.com/epsilon/archive/2013/01/13/2858944.html

weixin_30682415
关注
广度优先搜索（BFS）C++
阿怪的博客
10-12 554
广度优先搜索（BFS） 宽度优先搜索（BFS，Breadth-First Search）也是搜索的手段之一。宽度优先搜索是先搜索距离初始状态近的状态。也就是说，它是按照开始状态→只需1次转移就可以到达的所有状态→只需2次转移就可以到达的所有状态→……这样的顺序进行搜索 宽度优先搜索利用了队列进行计算，队列（Queue）支持push和pop两个操作，数据元素先进先出。其头文件为：#include <queue> 例题：迷宫的最短路径 题目描述 给定一个大小为 N×M 的迷宫。迷宫由通道和墙壁组成
迷宫问题 模拟队列 广度优先搜索
weixin_33973609的博客
12-18 82
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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路...
用广度优先搜索解迷宫问题
xyjikl
05-05 506
//By LYLtim      #include      const int di[4] = {0,1,0,-1},             dj[4] = {1,0,-1,0};      unsigned maze[5][5] = {       2, 1, 0, 0, 0,       0, 1, 0, 1, 0,       0, 0, 0, 0, 0,     
图的应用——深度优先／广度优先搜索遍历
10-26
在“图的应用——深度优先／广度优先搜索遍历”这个实验中，你需要实现两个核心函数：一个是深度优先搜索，另一个是广度优先搜索。你可以通过创建一个布尔型数组来记录节点是否已被访问，然后利用栈或队列来辅助遍历...
数据结构（C语言版） 栈与队列 迷宫问题
06-10
在C语言版的数据结构课程中，第三章深入探讨了两种基础但非常重要的数据结构——栈和队列，并应用它们解决实际问题，如迷宫问题。 栈是一种后进先出（LIFO）的数据结构，类似于我们日常生活中的叠放物品。它主要...
python每日算法 | 数据结构基础：栈与队列以及经典的迷宫问题
REPCHAOCHAO的博客
09-12 1301
python每日算法：数据结构基础知识（一）：栈与队列以及最经典的迷宫问题
不撞南墙不回头——深度优先搜索.docx
11-22
深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法，它的基本思想是尽可能深地探索树的分支。DFS通常使用栈作为辅助数据结构，遵循“后进先出”（LIFO）的原则，即最后进入栈的节点最先被处理。在遇到无法继续...
leetcode刷题笔记——广度优先搜索
md_Ji的博客
01-10 719
leetcode刷题笔记——广度优先搜索 目前完成的广度优先搜索相关的leetcode算法题序号： 简单：257 中等：200 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/reconstruct-itinerary 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 文章目录leetcode刷题笔记——广度优先搜索算法理解一、257题：二叉树的所有路径1.题干2.思路3.代码4.总结二、200题：岛屿数量1.题干2.思路3.代码
宽度搜索优先算法搜索迷宫最短距离
hzylmf的专栏
10-05 2133
BFS介绍： 宽度搜索优先按照距开始状态由近及远的顺序进行搜索，因此可以很容易用来求最短路径、最少操作之类问题的答案。它是按照开始状态->只需1次转移就能到达的所有状态->只需2次就能到达的所有状态->...这样的顺序进行搜索。对于同一个状态，bfs只经过一次，时间复杂度为O(状态数*转移方式)。BFS搜索利用了队列，搜索时首先将初始状态添加对队列中，此后不断从队列中取出状态，并把从该状态可以转
栈和队列的应用——迷宫问题（深度、广度优先搜索）
anmi3721的博客
09-21 925
一、迷宫问题 　　给一个二维列表，表示迷宫（0表示通道，1表示围墙）。给出算法，求一条走出迷宫的路径。 maze = [ [1,1,1,1,1,1,1,1,1,1], [1,0,0,1,0,0,0,1,0,1], [1,0,0,1,0,0,0,1,0,1], [1,0,0,0,0,1,1,0,0,1], [1,0,1,1,1,0,...
利用队列实现迷宫求解最短路径
Dedication_的博客
12-24 2408
#include "pch.h" #include <iostream> using namespace std; struct point { int x; int y; point *front;//前一个坐标 }; int aspect[4][2] = {//方向数组 {0,-1}, {1,0}, {-1,0}, {0,1}}; int main() ...
宽度优先搜索-----解决迷宫最短路径问题
浪舟子的博客
09-07 2187
宽度优先搜索-----解决迷宫最短路径问题 一、关于宽度优先搜索的知识 1.深度优先搜索利用栈进行计算，因此一般场景中采用递归的方式实现。 2.宽度优先搜索则利用队列进行计算，搜索时首先将初始状态添加到队列里，此后从队列的最前端不断取出状态， 把从该状态可以转移到的状态中尚未访问过的部分加入队列，如此往复，直至队列被取空或者找到问题的解。 3.宽度优先搜索按照距开始状态由近及远的顺序搜索，因此可以很容易的用来求最短路径、最少操作之类问题的答案。 二、迷宫最短路径问题 ​ 输出：22 三、算法分析
迷宫的最短路径（宽度优先搜索）
小白的博客
07-30 1130
题目 给定一个大小为N∣timesMN|times MN∣timesM的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四个的通道移动，请求出从起点到终点所需的最小步数。限制条件N,M≤100N,M\le 100N,M≤100。 输入 （’#‘,'.','S','G'分别表示墙壁、通道、起点和终点） N=10,M=12N=10, M=12N=10,M=12 #S######.# ........
迷宫的最短路径-BFS算法
zhlbjtu2016的博客
07-02 2358
系白书上的一道队列题，初来乍到谈一下我对这个最短路SPFA的算法的理解  首先队列是先进先出，即push元素增加队列尾部，pop移除队列头部的元素  这个算法注意要标记之前走过的位置，然后开一个二维数组封装一下每个位置到起始点的最短距离  在这些前提之下至于为什么这样是最短的，比如如果产生分岔的路，这多条分岔的路基本是同时行进的，  如果走到了同一个位置，先到的那条路已经把这个点走过了，做
反光柱定位算法-经典三边定位最小二乘法-直接法
最新发布
苏凯的博客
09-26 157
（二）计算姿态方式是我们已经通过最小二乘得到了小车在地图中的位置或者是雷达在地图中的位置，又因为我们知道雷达与小车的安装坐标，所以可以求解出一其中一个坐标的知量，通过小车在地图中坐标与雷达在地图中坐标可以得到一条向量，通过计算向量在地图中的角度就能得到姿态了。与最小二乘三边测量法相比，新算法在动态调整、优化过程和鲁棒性方面优势明显，尤其适合动态环境下的机器人定位，而最小二乘三边测量法在动态复杂环境中精度相对较低。（一）与（二）的区别主要是在计算姿态上的算法不同。经典三边定位最小二乘法 (法一)
简单题101. 对称二叉树 （python）20240922
Sep21m_wyy的博客
09-22 388
【代码】简单题101. 对称二叉树 （python）20240922。
每日算法2（翻转链表）
wdnmdfky的博客
09-25 212
接着进入循环，我们选不探讨循环条件，先研究循环语句，n2的next要存储n1，就是为了使最后的链表的next的空，n1=n2,n2=n3,if(n3)n3=n3->， n1是整个链表，n2=n3是为了指向后面的元素，在将后面的元素插入到n1前面，然后再让n1是指向头节点，最后5就是新的头节点。先来讲下最简单的算法，创建一个新链表，将原链表的元素挨个头插到新链表上，就实现了顺序表的逆转，这里就不示例代码了，在之前的链表有提及。让n1指向空，n2指向头，n3指向head->next。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值