DFS/BFS搜索迷宫路径

已于 2023-09-19 17:19:43 修改
阅读量1.4k 收藏 7
点赞数 1
分类专栏： C++ 数据结构 算法 文章标签： 深度优先 宽度优先 算法
于 2022-05-11 21:23:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42500831/article/details/124697869
版权
算法 同时被 3 个专栏收录
50 篇文章 4 订阅
订阅专栏
C++
40 篇文章 7 订阅
订阅专栏
数据结构
38 篇文章 7 订阅
订阅专栏

文章目录

一、DFS搜索迷宫路径

DFS依赖栈结构

先把左上角节点入栈，然后依次查看栈顶元素的右、下、左、上四个方向是否可以走，如果能走就把节点入栈，然后再依次查看依次查看栈顶元素的右、下、左、上四个方向；如果四个方向都不能走，就把栈顶元素出栈

最终栈空，则说明退回到了左上角的节点；右下角的节点入栈，则表示找到了出口
在这里插入图片描述
需要注意的是，每入栈一个节点：

  • 需要将当前节点到入栈节点的方向置为NO，保证如果走进死胡同回退后，不会再次往这个错误的方向走
  • 需要将刚入栈节点到当前节点的方向置为NO，保证走过去后不会以入栈的方式走回来，想走回来只能以出栈的方式回退
#include <iostream>
#include <stack>
#include <memory>

using namespace std;

const int RIGHT = 0;
const int DOWN = 1;
const int LEFT = 2;
const int UP = 3;

const int D_NUM = 4;

const int YES = 0;
const int NO = 1;

class Maze {
public:
	Maze(int row, int col)
		: row_(row)
		, col_(col)
	{
		p_maze_ = new Node*[row_];
		for (int j = 0; j < col_; j++) {
			p_maze_[j] = new Node[col_];
		}
	}

	~Maze() {
		for (int i = 0; i < row_; i++) {
			delete[] p_maze_[i];
		}
	}

	void init_node(int i, int j, int val) {
		p_maze_[i][j].x_ = i;
		p_maze_[i][j].y_ = j;
		p_maze_[i][j].val_ = val;
		// 右下左上
		for (int idx = 0; idx < D_NUM; idx++) {
			p_maze_[i][j].direction_[idx] = NO;
		}
	}

	void set_node_state() {
		for (int i = 0; i < row_; i++) {
			for (int j = 0; j < col_; j++) {
				if (p_maze_[i][j].val_ == 1) {
					continue;
				}
				if (j < col_ - 1 && p_maze_[i][j + 1].val_ == 0) {
					p_maze_[i][j].direction_[RIGHT] = YES;
				}
				if (i < row_ - 1 && p_maze_[i + 1][j].val_ == 0) {
					p_maze_[i][j].direction_[DOWN] = YES;
				}
				if (j > 0 && p_maze_[i][j - 1].val_ == 0) {
					p_maze_[i][j].direction_[LEFT] = YES;
				}
				if (i > 0 && p_maze_[i - 1][j].val_ == 0) {
					p_maze_[i][j].direction_[UP] = YES;
				}
			}
		}
	}

	void search_maze_path() {
		if (p_maze_[0][0].val_ == 1) {
			return;
		}

		st_.push(p_maze_[0][0]);
		while (!st_.empty()) {
			Node top = st_.top();
			int x = top.x_;
			int y = top.y_;

			if (x == row_ - 1 && y == col_ - 1) {
				// 已将右下角的节点入栈
				return;
			}
			
			if (p_maze_[x][y].direction_[RIGHT] == YES) {
				p_maze_[x][y].direction_[RIGHT] = NO;
				p_maze_[x][y + 1].direction_[LEFT] = NO;
				st_.push(p_maze_[x][y + 1]);
				continue;
			}
			if (p_maze_[x][y].direction_[DOWN] == YES) {
				p_maze_[x][y].direction_[DOWN] = NO;
				p_maze_[x + 1][y].direction_[UP] = NO;
				st_.push(p_maze_[x + 1][y]);
				continue;
			}
			if (p_maze_[x][y].direction_[LEFT] == YES) {
				p_maze_[x][y].direction_[LEFT] = NO;
				p_maze_[x][y - 1].direction_[RIGHT] = NO;
				st_.push(p_maze_[x][y - 1]);
				continue;
			}
			if (p_maze_[x][y].direction_[UP] == YES) {
				p_maze_[x][y].direction_[UP] = NO;
				p_maze_[x - 1][y].direction_[DOWN] = NO;
				st_.push(p_maze_[x - 1][y]);
				continue;
			}
			// 当前节点四周都不能走，需要回溯，元素出栈
			st_.pop();
		}
	}

	void show_path() {
		if (st_.empty()) {
			cout << "找不到路径！" << endl;
			return;
		}

		while (!st_.empty()) {
			Node top = st_.top();
			p_maze_[top.x_][top.y_].val_ = '*';
			st_.pop();
		}
		for (int i = 0; i < row_; i++) {
			for (int j = 0; j < col_; j++) {
				if (p_maze_[i][j].val_ == '*') {
					cout << "* ";
				}
				else {
					cout << p_maze_[i][j].val_ << " ";
				}
			}
			cout << endl;
		}
	}

private:
	struct Node {
		Node()
			:x_(0)
			,y_(0)
			,val_(0)
		{
			for (int i = 0; i < D_NUM; ++i) {
				direction_[i] = NO;
			}
		}
		int x_;
		int y_;
		int val_;
		int direction_[D_NUM];
	};

	Node** p_maze_;
	int row_;
	int col_;
	stack<Node> st_;  // 用于深度搜索迷宫路径
};

int main() {
	cout << "请输入迷宫的行列：";
	int row;
	int col;
	int val;
	cin >> row >> col;
	Maze maze(row, col);

	cout << "请输入迷宫的结构：" << endl;
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			cin >> val;
			maze.init_node(i, j, val);
		}
	}

	maze.set_node_state();

	maze.search_maze_path();

	maze.show_path();
	return 0;
}

在这里插入图片描述
在这种情况下，虽然找到了迷宫的出口，但这不是最优路径

二、BFS搜索迷宫路径

BFS依赖队列结构

把[0,0]节点入队列，开启循环，分别查看对头节点的右、上、左、下四个方向是否能走，把能走的节点入队列。处理完队头节点后则队头元素出队

由于先入队的先处理，那肯定是先将当前队头节点周围可走的节点全部入队，然后依次处理，再处理更远处的节点，这就是广度优先遍历
在这里插入图片描述
我们边入队队头节点周围可走的节点，边出队队头节点，如果最终找到了迷宫出口的路径，那也没有记录这条路径，我们需要额外开辟一个数组记录搜索路径的过程

在这里插入图片描述
在这里插入图片描述
如果找到了出口，我们从[m,n]出发倒推迷宫的路径，直到碰到[0,0]停止

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

const int RIGHT = 0;
const int DOWN = 1;
const int LEFT = 2;
const int UP = 3;

const int D_NUM = 4;

const int YES = 0;
const int NO = 1;

class Maze {
public:
	Maze(int row, int col)
		: row_(row)
		, col_(col)
	{
		p_maze_ = new Node * [row_];
		for (int j = 0; j < col_; j++) {
			p_maze_[j] = new Node[col_];
		}
		path_.resize(row * col);
	}

	~Maze() {
		for (int i = 0; i < row_; i++) {
			delete[] p_maze_[i];
		}
	}

	void init_node(int i, int j, int val) {
		p_maze_[i][j].x_ = i;
		p_maze_[i][j].y_ = j;
		p_maze_[i][j].val_ = val;
		// 右下左上
		for (int idx = 0; idx < D_NUM; idx++) {
			p_maze_[i][j].direction_[idx] = NO;
		}
	}

	void set_node_state() {
		for (int i = 0; i < row_; i++) {
			for (int j = 0; j < col_; j++) {
				if (p_maze_[i][j].val_ == 1) {
					continue;
				}
				if (j < col_ - 1 && p_maze_[i][j + 1].val_ == 0) {
					p_maze_[i][j].direction_[RIGHT] = YES;
				}
				if (i < row_ - 1 && p_maze_[i + 1][j].val_ == 0) {
					p_maze_[i][j].direction_[DOWN] = YES;
				}
				if (j > 0 && p_maze_[i][j - 1].val_ == 0) {
					p_maze_[i][j].direction_[LEFT] = YES;
				}
				if (i > 0 && p_maze_[i - 1][j].val_ == 0) {
					p_maze_[i][j].direction_[UP] = YES;
				}
			}
		}
	}

	void search_maze_path() {
		if (p_maze_[0][0].val_ == 1) {
			return;
		}

		queue_.push(p_maze_[0][0]);
		while (!queue_.empty()) {
			Node front = queue_.front();
			int x = front.x_;
			int y = front.y_;

			// 查看四个方向是否能走，把能走的节点放入队列
			if (p_maze_[x][y].direction_[RIGHT] == YES) {
				p_maze_[x][y].direction_[RIGHT] = NO;
				p_maze_[x][y + 1].direction_[LEFT] = NO;
				
				queue_.push(p_maze_[x][y + 1]);
				path_[x*row_ + y+1] = p_maze_[x][y];         // 表示是从p_maze_[x][y]走到p_maze_[x][y + 1]的
				if (is_exit(x, y + 1)) {
					return;
				}
			}
			if (p_maze_[x][y].direction_[DOWN] == YES) {
				p_maze_[x][y].direction_[DOWN] = NO;
				p_maze_[x + 1][y].direction_[UP] = NO;
				queue_.push(p_maze_[x + 1][y]);
				path_[(x+1)*row_ + y] = p_maze_[x][y];
				if (is_exit(x + 1, y)) {
					return;
				}
			}
			if (p_maze_[x][y].direction_[LEFT] == YES) {
				p_maze_[x][y].direction_[LEFT] = NO;
				p_maze_[x][y - 1].direction_[RIGHT] = NO;
				queue_.push(p_maze_[x][y - 1]);
				path_[x * row_ + y - 1] = p_maze_[x][y];
				if (is_exit(x, y - 1)) {
					return;
				}
			}
			if (p_maze_[x][y].direction_[UP] == YES) {
				p_maze_[x][y].direction_[UP] = NO;
				p_maze_[x - 1][y].direction_[DOWN] = NO;
				queue_.push(p_maze_[x - 1][y]);
				path_[(x - 1) * row_ + y] = p_maze_[x][y];
				if (is_exit(x - 1, y)) {
					return;
				}
			}
			// 处理完队头节点，则出队列
			queue_.pop();
		}
	}

	void show_path() {
		if (queue_.empty()) {
			cout << "迷宫不存在路径！" << endl;
		}
		int x = row_ - 1;
		int y = col_ - 1;
		while (true) {
			p_maze_[x][y].val_ = '*';
			if (x == 0 && y == 0) {
				break;
			}
			Node node = path_[x * row_ + y];
			x = node.x_;
			y = node.y_;
		}

		for (int i = 0; i < row_; ++i) {
			for (int j = 0; j < col_; ++j) {
				if (p_maze_[i][j].val_ == '*') {
					cout << "* ";
				}
				else {
					cout << p_maze_[i][j].val_ << " ";
				}
			}
			cout << endl;
		}
	}

private:
	bool inline is_exit(int x, int y) {
		return x == row_ - 1 && y == col_ - 1;
	}

	struct Node {
		Node()
			:x_(0)
			,y_(0)
			,val_(0)
		{
			for (int i = 0; i < D_NUM; ++i) {
				direction_[i] = NO;
			}
		}
		int x_;
		int y_;
		int val_;
		int direction_[D_NUM];
	};

	Node** p_maze_;
	int row_;
	int col_;
	queue<Node> queue_;  // 用于广度搜索路径
	vector<Node> path_;  // 用于记录路径
};

int main() {
	cout << "请输入迷宫的行列：";
	int row;
	int col;
	int val;
	cin >> row >> col;
	Maze maze(row, col);

	cout << "请输入迷宫的结构：" << endl;
	for (int i = 0; i < row; i++) {
		for (int j = 0; j < col; j++) {
			cin >> val;
			maze.init_node(i, j, val);
		}
	}

	maze.set_node_state();

	maze.search_maze_path();

	maze.show_path();
	return 0;
}

在这里插入图片描述

int main() {
	int m, n;
	cin >> m >> n;
	vector<vector<char>> grid(m, vector<char>(n));
	vector<vector<bool>> visited(m, vector<bool>(n));
	getchar();
	queue<pair<int, int>> q;
	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			grid[i][j] = getchar();
			if (grid[i][j] == 's') {
				q.push({i, j});
				visited[i][j] = true;
			}
			else if (grid[i][j] == '#') {
				visited[i][j] = true;
			}
		}
		getchar();
	}
	
	int ans = 0;
	bool isReach = false;
	vector<vector<int>> directions = { {0,-1},{0,1},{1,0},{-1,0} };
	while (!q.empty()) {
		int cnt = q.size();
		for (int i = 0; i < cnt; i++) {
			pair<int, int> pos = q.front();
			q.pop();
			int x = pos.first;
			int y = pos.second;
			if (grid[x][y] == 'e') {
				isReach = true;
				break;
			}
			for (auto d : directions) {
				int x1 = x + d[0];
				int y1 = y + d[1];
				if (x1 < 0 || x1 >= m || y1 < 0 || y1 >= n) {
					continue;
				}
				if (!visited[x1][y1]) {
					q.push({x1, y1});
					visited[x1][y1] = true;  // 放进去就访问过了
				}
			}
		}
		if (isReach) {
			break;
		}
		ans++;
	}
	if (isReach) {
		cout << ans;
	}
	else {
		cout << -1;
	}
	
	
	return 0;
}
bugcoder-9905
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
BFS & DFS 迷宫
Serence
08-08 331
上一篇“一文弄懂递归”中，埋了一个使用递归来找到迷宫的解的坑。这篇文章记录一下如何使用 BFS 和 DFS 来找到迷宫的解。 迷宫 这篇文章主要是针对一种被称为“完美迷宫”的特殊迷宫类型。一个完美迷宫是一个没有环路和不可进入的区域，起点和终点都由一条路径连接的迷宫。 下图显示了一个完美的迷宫，以及从左上角的入口到右下角的出口的路径: ------- -@@@@@- -----@- -@@@-@- -@---@- 你会接收到这样的一个输入，其中-代表通路，@代表墙。 针对这个输入，会提供一个
迷宫问题中的DFS和BFS
qq_50857039的博客
11-06 1284
迷宫问题与深搜和广搜 文章目录****迷宫问题与深搜和广搜****前言一、深度优先算法1）简介2）实例---->迷宫问题3）深搜的缺点二、广度优先搜索1）简介2）实例---->迷宫问题3）广搜的优缺点 前言 搜索算法是一种较为常见且基础的算法 最新在做迷宫问题的时候学习了深度优先搜索和广度优先搜索 写一个博客来总结一下 也方便以后自己复习 提示：以下是本篇文章正文内容，下面案例可供参考 一、深度优先算法 1）简介 深度优先算法（Depth-First-Search），可以简称为DFS，
【详解】求解迷宫所有路径（递归实现）----直接打穿迷宫
2301_80035594的博客
01-06 1059
介绍了递归算法的模型和栈帧的一些基本概念，和递归算法的一个应用求解迷宫所有路径（递归实现）超详细。
DFS与BFS寻找图中的所有路径（C++）
m0_52733659的博客
04-11 1753
【代码】DFS与BFS寻找图中的所有路径（C++）
数据结构与算法-DFS+BFS篇(迷宫问题)
最新发布
窗外风景随心变幻
05-07 874
迷宫问题是数据结构与算法DFS+BFS篇中比较典型且综合的题目，通过此类问题可以提高我们的代码实现能力，帮助我们掌握DFS以及BFS算法基础。对于稍有难度且重要的知识点我们要多多回顾并总结。
DFS递归之迷宫问题
Tom的博客
04-09 3910
DFS递归之迷宫问题： 1.能否逃出迷宫； 2.逃出迷宫的最短路径； 3.缺口迷宫。
迷宫的所有路径（回溯DFS）
m0_72121170的博客
08-07 721
【代码】迷宫的所有路径（回溯DFS）
迷宫（蓝桥杯C/C++）dfs详解
m0_73750670的博客
02-04 2295
迷宫C/C++题解
DFS求解迷宫问题
m0_69326632的博客
03-06 2147
DFS求解迷宫问题
python 随机生成迷宫并使用DFS和BFS来找到迷宫路径
07-29
使用python 随机生成迷宫，带有...界面还有按钮，能够采用DFS和BFS算法来找到从起点到终点的路径，生成的迷宫没有一条路径能够到达起点和终点，会做提示。 界面采用PySimpleGUI实现，总共200多行代码，需要可以下载哈
dfs-bfs-master.zip_bfs_dfs
09-24
深度优先搜索（DFS，Depth-First Search）与广度优先搜索（BFS，Breadth-First Search）是图论和树形结构中常用的两种遍历算法，它们在计算机科学中有着广泛的应用，如在算法设计、数据结构、游戏逻辑、网络爬虫等...
DFS和BFS.docx
08-21
在给出的迷宫例子中，DFS会先尝试所有可能的路径，而BFS则会优先尝试较短的路径。对于样例输入，两种方法会得到不同的路径输出，因为DFS可能找到非最短但仍然可行的路径，而BFS则确保找到最短路径。 ### 实现细节 ...
dfs-bfs.rar_dfs
09-19
深度优先搜索（DFS，Depth-First Search）和广度优先搜索（BFS，Breadth-First Search）是图论中的两种基本搜索算法，广泛应用于解决计算机科学中的各种问题，如遍历图、查找最短路径、判断连通性等。它们在数据结构...
DFS BFS 图.zip_DFS BFS_bfs_bfs dfs_dfs_dfs bfs输出图
09-20
深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search）是图论中的两种基本搜索算法，用于遍历或查找图中的所有节点。这两种算法都起始于图中的一个特定节点，通常称为起点，然后按照...
算法设计与分析 | 迷宫搜索（蓝桥杯Java）
鷾
03-12 1033
下图给出了一个迷宫的平面图，其中标记为 11 的为障碍，标记为 00 的为可以通行的地方。 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 1010 步。其中D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（3030 行 5050 列），请找出一种通过迷宫的方式。
经典算法----迷宫问题（找出所有路径）
m0_73633088的博客
10-07 3803
经典算法-----迷宫问题（栈的应用）-CSDN博客），但是这个方法只可以找到一条路径，那么今天我们就进一步去讲解迷宫问题，通过回溯算法来找到全部的路径，下面就一起来看看吧！同样的，每走到一个位置就要想该往哪一个方向去走，所以有东南西北这4个方向，每次往一个方向走之后就标记好当前方向和当前位置，然后同样的去进行分享的试探，当走到没路走的时候就进行原路返回。//试探方向存储结构int xx, yy;}Direction;//东南西北。
DFS练习-迷宫（最短路径）问题详解 一波三折 图片+文字
2301_79599253的博客
01-17 2498
dfs迷宫问题的详细解析，图文并茂，包含洛谷acwing上的两题。
【算法】（BFS/DFS）迷宫路径问题（C语言）
weixin_51450101的博客
05-01 7313
题目：现有一迷宫如下图所示，蓝色部分为墙壁，白色部分为通路，入口在左上角（1,1）处，出口在右下角（8,8）处，试找出一条路径以通过该迷宫（路径不能重叠）。
DFS遍历迷宫输出所有路径（借助数据结构栈）
NoBug
10-19 5215
可解决问题：输入n,m，可随机生成n*m大小的迷宫(伪随机数),也可手动输入迷宫,找到迷宫中的所有可行路径（八个方向：上下左右以及对角），输出路径以及路径长度。 C语言实现栈，并打成头文件方便使用： #ifndef stack_h #define stack_h #include <stdio.h> #include <stdlib.h> //栈中存位置以及遍历时所...
用bfs求多路径迷宫问题
09-02
多路径迷宫问题是一个经典的搜索问题，可以使用广度优先搜索（BFS）来解决。下面是使用BFS求解多路径迷宫问题的步骤： 1. 定义一个队列，用来存储待探索的节点。 2. 将迷宫的起点加入队列，并标记为已访问。 3. 当队列不为空时，循环执行以下步骤： - 从队列中取出一个节点作为当前节点。 - 判断当前节点是否为终点。若是，则找到一条路径，记录下来，并继续搜索。 - 若不是终点，则按照所有可能的移动方式（上、下、左、右）进行移动，并进行以下操作： - 检查新位置是否合法。若合法且未访问过，则将新节点加入队列，并标记为已访问。 4. 当队列为空时，搜索结束。所有的路径都已找到。 使用BFS求解多路径迷宫问题的关键在于利用队列按层探索的特性。通过不断扩展搜索的范围，可以找到所有可行的路径。 需要注意的是，由于可能存在多条路径，需要在达到终点后继续搜索并记录下可能的路径。可以使用深度优先搜索（DFS）来完成这一步骤。 综上所述，使用BFS可以有效地求解多路径迷宫问题，并找到所有可行的路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

bugcoder-9905

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

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

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

打赏作者

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

抵扣说明：

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

余额充值