迷宫问题 -- 深度优先搜索算法DFS

最新推荐文章于 2024-04-27 10:09:37 发布
最新推荐文章于 2024-04-27 10:09:37 发布
阅读量6.3k 收藏 38
点赞数 6
文章标签： 算法 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuechanba/article/details/120742524
版权

以下部分内容来自于B站视频 – 麦克老师讲算法

视频链接：https://www.bilibili.com/video/BV1bK4y1C7W2?p=2&spm_id_from=pageDriver.

迷宫示例图像如下：
在这里插入图片描述
程序实现使用了递归思想，没有用到堆栈知识。
在这里插入图片描述
实现的代码：

#include <iostream>
using namespace std;

/*
 * 由于这里使用数组的原因, 而数组的初始值是为0的,
 * 所以不能让 0 表示空地, 1 表示障碍物。
 * 这里用 1 表示空地, 2 表示障碍物。
 */

int start_x, start_y; //起点坐标：(start_x, start_y)
int end_x, end_y; //终点坐标：(endx, endy)

int min_step = 99999;//一开始给它一个很大的数

//地图,放100行100列
int map[100][100];//1表示空地,2表示障碍物
int visit[100][100];//1表示访问,0表示未访问

void dfs(int x,int y,int step)
{
	if (x== end_x && y== end_y)
	{
		//如果当前步数小于最小值，就更新
		if (step < min_step)
			min_step = step;
		return;//回溯
	}
	//顺时针试探
	//右
	//如果当前位置的右边为空地且没有访问过
	if (map[x][y + 1] == 1 && visit[x][y + 1] == 0)
	{
		//将右边的点设置为已访问
		visit[x][y + 1] = 1;
		dfs(x, y + 1, step + 1);
		visit[x][y + 1] = 0;
	}

	//下
	if (map[x+1][y] == 1 && visit[x+1][y] == 0)
	{
		//将下边的点设置为已访问
		visit[x+1][y] = 1;
		dfs(x + 1, y, step + 1);
		visit[x+1][y] = 0;
	}
	//左
	if (map[x][y - 1] == 1 && visit[x][y - 1] == 0)
	{
		//将左边的点设置为已访问
		visit[x][y - 1] = 1;
		dfs(x, y - 1, step + 1);
		visit[x][y - 1] = 0;
	}
	//上
	if (map[x-1][y] == 1 && visit[x-1][y] == 0)
	{
		//将上边的点设置为已访问
		visit[x-1][y] = 1;
		dfs(x-1, y, step + 1);
		visit[x-1][y] = 0;
	}
	return;
}

int main()
{
	int m, n;

	printf("请设置地图的行数和列数，以逗号分隔:\n");
	scanf("%d,%d",&m,&n);

	printf("请输入 %d 行 %d 列的地图:\n",m,n);
	for (int i=1;i<=m;i++)
	{ 
		for (int j = 1; j <= n; j++)
			scanf("%d",&map[i][j]);//0表示空地,1表示障碍物
	}
	
	printf("请输入起点坐标,以逗号分隔:\n");
	scanf("%d,%d", &start_x,&start_y);

	printf("请输入终点坐标,以逗号分隔:\n");
	scanf("%d,%d", &end_x, &end_y);

	visit[start_x][start_y] = 1;
	dfs(start_x, start_y,0);
	printf("最短步数为 %d 步.\n", min_step);
	
	system("pause");
	return 0;
}

测试数据如下：逗号为英文字符，可以在记事本中一起直接复制粘贴。
在这里插入图片描述
在这里插入图片描述
上述代码还有优化的地方。
在这里插入图片描述

//定义方向数组
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };

void dfs(int x,int y,int step)
{
	if (x== end_x && y== end_y)
	{
		//如果当前步数小于最小值，就更新
		if (step < min_step)
			min_step = step;
		return;//回溯
	}
	//顺时针试探
	for (int k = 0; k < 4; k++)
	{
		//tx,ty表示下一个方向的试探坐标
		int tx, ty;
		tx = x + dx[k];
		ty = y + dy[k];
		if (map[tx][ty]==1&& visit[tx][ty]==0)
		{
			visit[tx][ty] = 1;
			dfs(tx, ty, step + 1);
			visit[tx][ty] = 0;
		}
	}
	return;
}

以下部分内容来自于B站视频 – 懒猫老师-数据结构-(8)栈的应用：迷宫问题(DFS)

视频链接：https://www.bilibili.com/video/BV1oE41177wk?spm_id_from=333.999.0.0.
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
M+2和N+2表示的是围墙的两行和两列。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
这里走的迷宫遵循的都是顺时针原则：即 右-下-左-上 的原则。
在这里插入图片描述
最原汁原味版的迷宫程序
stack.h

#ifndef _STACK_H_
#define _STACK_H_

#include "maze.h"

const int MAX_SIZE = 100;//定义栈最大值常量

typedef void llist_op(struct Box recode);

template <class DataType>
class Stack
{
private:
	struct Box* data;
	int size;
	int top;

public:
	Stack();
	Stack(int s);
	~Stack();
	void push(DataType ch);
	DataType pop();
	DataType getTop();
	bool isEmpty();
	bool isFull();
	void setNull();
	void travel(llist_op op);
	class Full {};
	class Empty {};			//由于这两个类都是放在Stack这个类声明的里面, 所以我们将其称为异常内部类
};

typedef Stack<struct Box> BoxStack;

#endif // !_STACK_H_

stack.cpp

#include "stack.h"

template <class DataType>
Stack<DataType>::Stack()
{
	size = MAX_SIZE;
	top = -1;
	data = new DataType[MAX_SIZE];//缺省构造函数分配最大内存空间
}

template <class DataType>
Stack<DataType>::Stack(int s)
{
	size = s;
	top = -1;
	data = new DataType[size];//根据指定的大小分配栈的内存空间
}

//析构函数
template <class DataType>
Stack<DataType>::~Stack()
{
	delete[]data;//内存回收
}

template <class DataType>
void Stack<DataType>::push(DataType ch)
{
	//当堆栈是满时,丢出异常对象
	if (isFull())
		throw Full();
	data[++top] = ch;
}

template <class DataType>
DataType Stack<DataType>::getTop()			//成员函数：获得栈顶元素（不出栈）
{
	//当堆栈是空时,丢出异常对象
	if (isEmpty())
		throw Empty();
	return data[top];
}

template <class DataType>
bool Stack<DataType>::isEmpty()
{
	if (top == -1)
		return true;
	else
		return false;
}

template <class DataType>
bool Stack<DataType>::isFull()
{
	if (top+1 == size)
		return true;
	else
		return false;
}

template <class DataType>
DataType Stack<DataType>::pop()		//成员函数：出栈
{
	if (isEmpty())
		throw Empty();
	return data[top--]; //先出栈,top再自减
}

template <class DataType>
void Stack<DataType>::setNull()
{
	top = -1;
}

template <class DataType>
void Stack<DataType>::travel(llist_op op)
{
	if (isEmpty())
		throw Empty();

	for (int i = 0; i <= top; i++)
	{
		op( data[i]);
	}
}

template class Stack<Box>;

maze.h

#ifndef _MAZE_H_
#define _MAZE_H_

#include "stack.h"

//方向试探表示
typedef struct
{
	//x,y方向的增量
	int incX, incY;

}Direction;

//起点和终点坐标
typedef struct Setting
{
	int start_x, start_y;	//起点坐标：(start_x, start_y)
	int end_x, end_y;		//终点坐标：(endx, endy)
}Setting;

//栈中数据元素的组织
//栈中元素是一个由行、列、方向组成的三元组
typedef struct Box {
	int x;
	int y;	 //当前访问的迷宫格子的x,y坐标
	int di;  //当前方向
}Box;

#endif // !_MAZE_H_

maze.cpp

#include <iostream>
#include <iomanip>

#include "maze.h"
#include "stack.h"

using namespace std;

int maze[101][101];//0表示空地,1表示障碍物

bool findPath(int map[101][101], Direction direct[], BoxStack &s, Setting set)
{
	Box temp;
	int x, y, di;	//迷宫格子当前处理单元的xy坐标和方向
	int line, col;	//迷宫数组下一个单元的行坐标和列坐标

	map[set.start_x][set.start_y] = -1;
	temp = { 1,1,-1 };
	s.push(temp);
	while (!s.isEmpty()) //栈不为空
	{
		temp = s.pop();
		x = temp.x; y = temp.y; di = temp.di + 1;
		while (di < 4) //方向未尝试完
		{
			line = x + direct[di].incX;
			col = y + direct[di].incY;
			if (map[line][col] == 0)
			{
				temp = { x,y,di };
				s.push(temp);
				x = line; y = col; map[line][col] = -1;
				if (x == set.end_x && y == set.end_y)
					return true;//迷宫有路
				else di = 0;
			}
			else
				di++;
		}
	}
	return false;//迷宫没有路
}

void creatMaze(int m, int n)
{
	int i, j = 0;
	for (i = 0; j <= n + 1; j++)
		maze[i][j] = 1; //0表示空地,1表示障碍物
	for(i = m+1,j=0; j <= n + 1; j++)
		maze[i][j] = 1; //0表示空地,1表示障碍物
	for(i=0,j = 0; i <= m ; i++)
		maze[i][j] = 1; //0表示空地,1表示障碍物
	for (i=0,j = n+1; i <= m; i++)
		maze[i][j] = 1; //0表示空地,1表示障碍物
}

void Print_Maze(int m, int n)
{
	cout << "迷宫生成如下：";

	for (int i = 0; i <= m + 1; i++)
	{
		cout << endl;
		for (int j = 0; j <= n + 1; j++)
			cout << setw(3)<<maze[i][j] ;
	}

	cout << endl;
}

//如果用户能给我提供这样一个数据，我就可以将它给输出出来.
void print_s(Box recode)
{
	cout << recode.x <<" "<<recode.y<<" "<<recode.di<< endl;
}

int main(void)
{
	int m, n;
	Direction direct[4];
	Setting set;
	BoxStack s;

	direct[0].incX = 0; direct[0].incY = 1;//右
	direct[1].incX = 1; direct[1].incY = 0;//下
	direct[2].incX = 0; direct[2].incY = -1;//左
	direct[3].incX = -1; direct[3].incY = 0;//上

	cout<<"请设置迷宫的行数和列数，最大行数和列数均为100，输入以空格分隔。"<<endl;

	while (1)
	{
		cin >> m >> n;
		if (m > 100 || n > 100)
			cout << "输入有误，请重新输入：" << endl;
		else
			break;
	}

	cout << "请输入" << m << "行" << n <<"列的迷宫，"<< "输入以空格分隔。"<<endl;

	for (int i = 1; i <= m; i++)
	{
		for (int j = 1; j <= n; j++)
			cin >> maze[i][j]; //0表示空地,1表示障碍物
	}

	creatMaze(m, n);
	
	Print_Maze(m, n);

	cout << "请输入起点坐标，起点坐标需为空地且在地图上，输入以空格分隔。" << endl;
	while (1)
	{
		cin >> set.start_x >> set.start_y;
		if (set.start_x > m || set.start_y > n||maze[set.start_x][set.start_y]==1)
			cout << "起点坐标设置有误,请重新输入:" << endl;
		else
			break;
	}

	cout << "请输入终点坐标，终点坐标不能与起点坐标相同、需为空地且在地图上，输入以空格分隔。" << endl;
	while (1)
	{
		cin >> set.end_x >> set.end_y;
		if (set.end_x > m || set.end_y > n || maze[set.end_x][set.end_y] == 1|| (set.end_x== set.start_x&& set.end_y == set.start_y))
			cout << "终点坐标设置有误,请重新输入:" << endl;
		else
			break;
	}

	if (findPath(maze, direct, s, set))
	{
		cout << "寻路成功" << endl;
		try
		{
			s.travel(print_s);
		}
		catch (Stack<struct Box>::Empty)
		{
			cout << "Stack Empty" << endl;
		}
	}
	else
		cout << "迷宫没有路" << endl;
	
	Print_Maze(m, n);

	system("pause");
	return 0;
}

在这里插入图片描述

xuechanba
关注
  • 6
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
深度优先搜索算法—DFS
Dear_Mr的博客
04-23 896
深度优先搜索算法—DFS图的遍历方法主要有两种：深度优先搜索遍历（DFS）和广度优先搜索遍历DFS深度优先搜索遍历类似于树的先序遍历，尽可能从纵深方向进行搜索，简单来说，DFS就是想找到最长的路径，基本思想是从图某个顶点V0V_0开始，访问此顶点，然后依次从V0V_0的各个没有访问的邻接点出发深度优先搜索遍历图，直至图中所有和V0V_0有路径连通的顶点都被访问到，若图是连通图，则遍历结束，否则，图中
MATLAB实现迷宫的递归深度优先遍历算法
09-24
在本文中，我们将深入探讨如何使用MATLAB实现迷宫的递归深度优先遍历（DFS）算法。MATLAB是一种强大的编程环境，尤其适用于数值计算、符号计算和数据分析，同时也是实现算法的良好平台。深度优先遍历是一种图遍历...
【游戏编程】AI-迷宫寻路算法-深度优先搜索和广度优先搜索
Health's Box
10-05 2209
状态空间搜索，如果按专业点的说法就是将问题求解过程表现为从初始状态到目标状态寻找这个路径的过程。通俗点说，就是在解一个问题时，找到一条解题的过程可以从求解的开始到问题的结果（好象并不通俗哦）。由于求解问题的过程中分枝有很多，主要是求解过程中求解条件的不确定性，不完备性造成的，使得求解的路径很多这就构成了一个图，我们说这个图就是状态空间。问题的求解实际上就是在这个图中找到一条路径可以从开始到结果。这
深度优先搜索（迷宫问题）
2302_80297670的博客
01-28 621
同第一个代码一样，需要设一个book[]数组来判断是否走过，如果没走过并且不是死路，就可以进入，然后再if中再次调用dfs函数去走下一步，这就用到嵌套了，这是一步很巧妙的写法，如果到达了终点也可以通过这一层层的嵌套进行回溯，这也是为什么dfs函数后面将book又变成0，即未走过了。上面这个题就是简单的用深度优先搜索来解决的迷宫问题，就是下面这个代码的进阶版，即二维数组的版本，只要了解下面代码原理，就可以由点及面，解决这个简单的走迷宫问题。最后输入迷宫的起点坐标（x,y)和小哈所在的位置（q，p）。
深度优先生成迷宫（算法）
最新发布
2301_76767854的博客
04-27 926
具体来说，当迷宫的大小增加时，算法的运行时间和空间复杂度均呈现出线性增长的趋势，时间复杂度为n^2。/*int* ptr = (int* )malloc(3*sizeof(int))用malloc开一块内存来存储长度为3的数组，迷宫°是我们小的时候经常玩的游戏，可能我们小的时候对这个游戏比较好奇，大多数并没有在意其中存在的一些原理。//地图长度L，包括迷宫主体40，外侧的包围的墙体1+1，最外侧包围路径1+1。
C语言使用深度优先搜索算法解决迷宫问题(堆栈)
08-29
主要介绍了C语言使用深度优先搜索算法解决迷宫问题,涉及C语言堆栈的使用与深度优先算法解决迷宫问题的相关操作技巧,需要的朋友可以参考下
迷宫算法（DFS）
热门推荐
m0_53157173的博客
03-07 1万+
1.如果采用堆栈进行迷宫探测，则称之为深度优先搜索（DFS），它和递归的探测思路是基本一致的，可以看成是递归方式的非递归版本； 2.采用队列进行迷宫探测，则是广度优先搜索（BFS），广度优先搜索法利用队列的特点，一层层向外扩展查找可走的方块，直到找到出口为止，最先找到的这个答案就必然是最短的。 如果打比喻来说，DFS更适合模拟机器人走迷宫的方式，看到一个方向是通的，就一直走下去，遇到死胡同就退回；BFS则好比一个人站在迷宫入口处，拿出一堆小探测器，每个小探测器帮他搜索一个可能的路径去寻找，第一个找到出口的
DFS解决迷宫问题
weixin_47525457的博客
08-30 2459
DFS解决树的问题比较常见也比较简单，通常用栈来解决。现在来看看DFS怎么解决迷宫问题，理解好这个解题思路可以扩展到解更复杂的题。 在起点位置按右，下，左，上的顺序遍历，比如上图，起点右边为空，则走到右边（第1步）；第1步的右边为障碍物则判断下方是否为空，为空即走第二步；同理第二步优先判断能否往右走，若右边为障碍物则判断下、左、右；直到到达终点。下图为遍历出来的其中一条路线。按照这个原理可以找出每一条路线，记录每一条路线的总长，得到最短的路径长度。 class Solution { int p,q;
迷宫问题（进阶版）——深度优先算法
liuwenhao_1的博客
01-11 1371
迷宫问题（进阶版）——深度优先算法
迷宫生成算法---深度优先算法(基于python)
ghost_him的博客
04-26 3182
迷宫生成算法---深度优先算法总体的目录版权及协议声明1. 深度优先算法的原理与思路二．迷宫的制作迷宫的总体的创建。三.代码的实现 总体的目录 版权及协议声明 本文章遵循CC BY-NC 4.0协议,即允许共享,不允许商用,且必须署名 1. 深度优先算法的原理与思路 首先来看一下算法导论上的解释： 深度优先搜索总是对最近才发现的结点v的出发边进行探索，直到该结点的所有出发边都被发现为止。一但结点v的所有出发边都被发现，搜索则“回溯”到v的前驱结点（v是经过该结点才被发现的），来搜索该前驱结点的出发边。该过
深度优先搜索构建迷宫（DFS算法）动态构建过程
11-23
广度优先搜索构建迷宫（BFS算法）动态构建过程的python 源代码，详情请移步本人博客<迷宫与寻路可视化（一）深度优先搜索构建迷宫（DFS算法）>https://blog.csdn.net/Accelerato/article/details/98903522
基于python的深度优先搜索算法DFS设计与实现
05-01
深度优先搜索（Depth-First Search, DFS）是一种用于遍历或搜索树或图的算法，其基本思想是尽可能深地探索树的分支。在Python中实现DFS，我们可以利用递归或者栈来达到目的。本篇文章将详细介绍如何在Python中设计和...
基于DFS深度优先搜索算法的迷宫路线搜索matlab仿真.包含程序操作录像,代码中文注释
10-14
3.内容： 基于DFS深度优先搜索算法的迷宫路线搜索matlab仿真。深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法。这种算法会尽可能深的搜索树的分支，当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那...
迷宫问题 | 深度优先
qq_57663276的博客
01-09 1407
深度优先解决迷宫问题
【算法详解 | DFS算法】深度优先搜索解走迷宫问题 | 深度优先图遍历
来都来了，点篇看看吧（=
11-09 5841
本文将会详细讲解如何使用DFS算法解决走迷宫问题，一篇文章秒杀所有难点！内容简单直观，我家盆栽看完都学会了！
算法设计与分析 | 迷宫搜索（蓝桥杯Java）
鷾
03-12 1028
下图给出了一个迷宫的平面图，其中标记为 11 的为障碍，标记为 00 的为可以通行的地方。 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 1010 步。其中D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（3030 行 5050 列），请找出一种通过迷宫的方式。
DFS求解迷宫问题
m0_69326632的博客
03-06 2129
DFS求解迷宫问题
搜索算法（迷宫问题）
VinciB的博客
03-08 2379
搜索算法 盼来盼去终于又要开始学习算法了！ 笔者自学算法，所以学习顺序以个人舒服的形式！ 一，DFS（深搜） 用例子来看： 问题： 有一个迷宫，以1 2形式来表示————1表示是空地，即可以行走，2表示是障碍物，即无法通行。该迷宫由一个矩阵形式表示。 即 1  1  2  1 1  1  1  1 1  1  2  1 1  2  1  1 1  1  1  2 有终点和起点，我们需要计算从起点到达终点的最短路径！ 准备代码为 int q,p,step;//（p，q）为终点坐标 int mmin=9
DFS递归之迷宫问题
Tom的博客
04-09 3880
DFS递归之迷宫问题： 1.能否逃出迷宫； 2.逃出迷宫的最短路径； 3.缺口迷宫。
C语言使用深度优先搜索算法解决迷宫问题
06-03
好的，我可以为您讲解C语言使用深度优先搜索算法解决迷宫问题。深度优先搜索算法是一种用于遍历或搜索树或图的算法，它从起点开始，尽可能深地搜索每个可能的路径，直到找到目标节点或无法继续搜索为止。 在解决迷宫问题时，我们可以将迷宫看作一个图，其中每个格子都是一个节点，相邻的格子之间有一条边。我们可以使用深度优先搜索算法从起点开始遍历图，直到找到终点为止。在搜索过程中，我们需要记录当前路径，并且每次遍历到一个节点时，都需要判断它是否是终点，如果是终点则搜索结束，否则继续向下搜索。 以下是C语言代码示例： ```c #include<stdio.h> #define ROW 5 #define COL 5 int maze[ROW][COL] = { {0, 0, 0, 0, 0}, {0, 1, 1, 0, 0}, {0, 1, 1, 0, 0}, {0, 0, 0, 1, 0}, {0, 0, 0, 1, 0} }; int visited[ROW][COL] = {0}; //记录节点是否被访问过 int dx[4] = {0, 0, 1, -1}; //定义四个方向的移动 int dy[4] = {1, -1, 0, 0}; void dfs(int x, int y){ if(x<0 || x>=ROW || y<0 || y>=COL) return; //越界返回 if(visited[x][y] || maze[x][y]) return; //已访问或者是墙返回 visited[x][y] = 1; //标记为已访问 if(x == ROW-1 && y == COL-1){ //到达终点 printf("Find the way!\n"); return; } for(int i=0; i<4; ++i){ //向四个方向进行搜索 int nx = x + dx[i]; int ny = y + dy[i]; dfs(nx, ny); } } int main(){ dfs(0, 0); //从起点开始搜索 return 0; } ``` 在上述代码中，我们使用深度优先搜索算法从起点开始遍历迷宫，并且使用visited数组记录节点是否被访问过。在搜索过程中，我们向四个方向进行搜索，直到找到终点或者无法继续搜索为止。如果找到了终点，则输出"Find the way!"，搜索结束。 希望这个例子可以帮助您理解C语言使用深度优先搜索算法解决迷宫问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xuechanba

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值