[C/C++] -- 搜索迷宫路径

已于 2024-05-10 10:24:44 修改
阅读量323 收藏 1
点赞数 4
分类专栏： C/C++ 算法 文章标签： c++ 深度优先 开发语言
于 2024-05-09 09:51:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Afison/article/details/138600514
版权

DFS（深度优先搜索）和BFS（广度优先搜索）是两种常用的图遍历算法，它们在搜索图或树中的节点时有着不同的策略和特点。

  1. 深度优先搜索 (DFS):

    • 在DFS中，从起始节点开始，沿着一条路径尽可能深地搜索，直到到达叶子节点或者无法继续搜索为止，然后回溯到上一个节点，选择另一条路径继续搜索，直到所有节点都被访问。
    • DFS通常使用递归或者栈来实现，递归是自然而直观的实现方式，而使用栈可以避免递归的潜在问题（如栈溢出）。
    • DFS的优点是在搜索过程中不需要记录所有访问过的节点，因此占用的空间较少。
    • 适用于寻找深度路径，比如解决迷宫问题、寻找图的连通分量等。

  2. 广度优先搜索 (BFS):

    • 在BFS中，从起始节点开始，首先访问起始节点的所有邻居节点，然后依次访问这些邻居节点的邻居节点，以此类推，直到所有节点都被访问。
    • BFS通常使用队列来实现，保证了节点的访问顺序是按照距离起始节点的距离逐层递增的。
    • BFS的优点是可以找到起始节点到目标节点的最短路径，而且在无权图中具有最优性（即找到的第一个解就是最短路径）。
    • 适用于寻找最短路径，比如在迷宫中找到最短路径、在社交网络中找到两个人之间的最短关系链等。

1.深度优先遍历DFS

设计一个程序，能够对给定的迷宫进行路径搜索，并输出一条从起点到终点的路径。具体来说，程序需要实现以下功能：

  1. 接受用户输入的迷宫地图，包括迷宫的行数和列数，以及每个格子的状态（0 表示可通行，1 表示不可通行）。
  2. 使用深度优先搜索算法（DFS）对迷宫进行搜索，找到从起点到终点的一条路径。
  3. 输出搜索到的路径。

入栈以后，然后我们查看栈顶元素，是(0,0)这个节点。栈现在不为空，取栈顶元素，先看它右边能不能走，能走的话，就一直向右走，它右边是0，就入栈了。

_pMaze[0][0]._val == 1
    return;
_stack. Push(_pMaze[0][0]);//左上角节点入栈 
while (!_stack. Empty())//栈不为空 
	Node top = _stack. Top();

 如果栈顶元素的右边可以走的话，我们要把当前节点的右方向改成不能走，把右边节点的左方向改成不能走。因为不能走回头路，而且因为路子走不通回退后也不能继续走相同的死路。

//往右方向寻找
			if (_pMaze[x][y]._state[RIGHT] == YES)
			{
				_pMaze[x][y]._state[RIGHT] = NO;
				_pMaze[x][y + 1]._state[LEFT] = NO;
				_stack.push(_pMaze[x][y + 1]);
				continue;

深度遍历入栈后，不用判断之前节点的方向。continue后，重新取栈顶元素，继续进行判断。同理，如果右边不能走，下边可以走的话：

//往下方向寻找
			if (_pMaze[x][y]._state[DOWN] == YES)
			{
				_pMaze[x][y]._state[DOWN] = NO;
				_pMaze[x + 1][y]._state[UP] = NO;
				_stack.push(_pMaze[x + 1][y]);
				continue;
			}

 同理：左方向

//往左方向寻找
			if (_pMaze[x][y]._state[LEFT] == YES)
			{
				_pMaze[x][y]._state[LEFT] = NO;
				_pMaze[x][y - 1]._state[RIGHT] = NO;
				_stack.push(_pMaze[x][y - 1]);
				continue;
			}

如果栈顶元素判断完四个方向都不能走，就是到死路了，就把栈顶元素出栈。
然后再取栈顶元素，进行判断，如果它的4个方向都不能走，就出栈，如果栈为空，则迷宫无通路。如果有方向能走，就继续走下去。以此类推下去。但是，都要判断一下此节点是不是右下角的节点，如果是，就是找到通路了。

//已经找到右下角出口得迷宫路径
			if (x == _row - 1 && y == _col - 1)
			{
				return;
			}

 完整代码：

#include <iostream>
#include <stack>
using namespace std;

//定义迷宫每一个节点的四个方向
const int RIGHT = 0;//右 
const int DOWN = 1;//下 
const int LEFT = 2;//左 
const int UP = 3;//上 

//迷宫每一个节点方向的数量
const int WAY_NUM = 4;

//定义节点行走状态
const int YES = 4;//当前方向可以走 
const int NO = 5;//当前方向不能走 

//迷宫
class Maze
{
public:
	//初始化迷宫，根据用户输入的行列数，生成存储迷宫路径信息的二维数组
	Maze(int row, int col)
		:_row(row)
		, _col(col)
	{
		_pMaze = new Node*[_row];//注意元素类型是Node 
		for (int i = 0; i < _row; ++i)
		{
			_pMaze[i] = new Node[_col];
		}
	}

	//初始化迷宫路径节点信息
	void initNode(int x, int y, int val)
	{
		_pMaze[x][y]._x = x;
		_pMaze[x][y]._y = y;
		_pMaze[x][y]._val = val;
		//节点四个方向默认的初始化都为不能走 
		for (int i = 0; i < WAY_NUM; ++i)
		{
			_pMaze[x][y]._state[i] = NO;
		}
	}

	//初始化迷宫0节点四个方向的行走状态信息 当前节点右下左上，如果是0，改成可以走 
	void setNodeState()
	{
		for (int i = 0; i < _row; ++i)
		{
			for (int j = 0; j < _col; ++j)
			{
				if (_pMaze[i][j]._val == 1)
				{
					continue;//不用调整了，因为走不到值为1的节点 
				}
				
                //j不能取到最后一列，不然就判断越界了 
				if (j < _col - 1 && _pMaze[i][j + 1]._val == 0)
				//逻辑&，是先计算左边的表达式，左边如果是false，右边就不用计算了 
				{
					_pMaze[i][j]._state[RIGHT] = YES;
				}

				if (i < _row - 1 && _pMaze[i + 1][j]._val == 0)
				{
					_pMaze[i][j]._state[DOWN] = YES;
				}
				
                //j不用取第一类，因为本身就不能走 
				if (j > 0 && _pMaze[i][j - 1]._val == 0)
				{
					_pMaze[i][j]._state[LEFT] = YES;
				}

				if (i > 0 && _pMaze[i - 1][j]._val == 0)
				{
					_pMaze[i][j]._state[UP] = YES;
				}
			}
		}
	}

	//深度搜索迷宫路径
	void searchMazePath()
	{
		if (_pMaze[0][0]._val == 1)
		{
			return;
		}
		_stack.push(_pMaze[0][0]);//左上角节点入栈 

		while (!_stack.empty())//栈不为空 
		{
			Node top = _stack.top();
			int x = top._x;
			int y = top._y;

			//已经找到右下角出口得迷宫路径
			if (x == _row - 1 && y == _col - 1)
			{
				return;
			}

			//往右方向寻找
			if (_pMaze[x][y]._state[RIGHT] == YES)
			{
				_pMaze[x][y]._state[RIGHT] = NO;
				_pMaze[x][y + 1]._state[LEFT] = NO;
				_stack.push(_pMaze[x][y + 1]);
				continue;
			}

			//往下方向寻找
			if (_pMaze[x][y]._state[DOWN] == YES)
			{
				_pMaze[x][y]._state[DOWN] = NO;
				_pMaze[x + 1][y]._state[UP] = NO;
				_stack.push(_pMaze[x + 1][y]);
				continue;
			}

			//往左方向寻找
			if (_pMaze[x][y]._state[LEFT] == YES)
			{
				_pMaze[x][y]._state[LEFT] = NO;
				_pMaze[x][y - 1]._state[RIGHT] = NO;
				_stack.push(_pMaze[x][y - 1]);
				continue;
			}

			//往上方向寻找
			if (_pMaze[x][y]._state[UP] == YES)
			{
				_pMaze[x][y]._state[UP] = NO;
				_pMaze[x - 1][y]._state[DOWN] = NO;
				_stack.push(_pMaze[x - 1][y]);
				continue;
			}

			_stack.pop();
		}
	}

	//打印迷宫路径搜索结果
	void showMazePath()
	{
		if (_stack.empty())
		{
			cout << "不存在一条迷宫路径！" << endl;
		}
		else
		{
			while (!_stack.empty())//栈不为空，取出节点坐标，相应值调整为* 
			{
				Node top = _stack.top();
				_pMaze[top._x][top._y]._val = '*';
				_stack.pop();
			}

			for (int i = 0; i < _row; ++i)//打印迷宫
			{
				for (int j = 0; j < _col; ++j)
				{
					if (_pMaze[i][j]._val == '*')
					{
						cout << "* ";
					}
					else
					{
						cout << _pMaze[i][j]._val << " ";
					}
				}
				cout << endl;
			}
		}
	}
private:
	//定义迷宫节点路径信息
	struct Node
	{
		int _x;//节点的横坐标 
		int _y;//节点的纵坐标 
		int _val;//节点的值
		int _state[WAY_NUM];//记录节点四个方向的状态(左右上下)
		//4个元素位置(左右上下)，存储yes或者no 
	};

	Node **_pMaze;//动态生成迷宫路径(动态开辟二维数组) 
	int _row;//迷宫的行 
	int _col;//迷宫的列 
	stack<Node> _stack;//栈结构，辅助深度搜索迷宫路径
};

int main()
{
	cout << "请输入迷宫的行列数(例如：10 10):";
	int row, col, data;
	cin >> row >> col;

	Maze maze(row, col);//创建迷宫对象

	cout << "请输入迷宫的路径信息(0表示可以走，1表示不能走):" << endl;
	for (int i = 0; i < row; ++i)//只能获取i,j和data值，节点的4个方向的行走状态还不能初始化 
	{
		for (int j = 0; j < col; ++j)
		{
			cin >> data;
			//可以初始化迷宫节点的基本信息
			maze.initNode(i, j, data);
		}
	}

	//开始设置所有节点的四个方向的状态
	maze.setNodeState();

	//开始从左上角搜索迷宫的路径信息了
	maze.searchMazePath();

	//打印迷宫路径搜索的结果
	maze.showMazePath();

	return 0;
}

 

 2.广度优先遍历BFS

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

//定义方向
const int RIGHT = 0;
const int DOWN = 1;
const int LEFT = 2;
const int UP = 3;
const int WAY_NUM = 4;

//定义行走状态
const int YES = 4;
const int NO = 5;

//迷宫
class Maze
{
public:
	Maze(int row, int col)
		:_row(row)
		, _col(col)
	{
		_pMaze = new Node*[_row];//开辟迷宫二维数组 
		for (int i = 0; i < _row; ++i)
		{
			_pMaze[i] = new Node[_col];
		}

		//node._x*_row + node._y
		_pPath.resize(_row * _col);//辅助数组开辟空间 
	}

	void initNode(int x, int y, int val)//初始化为No 
	{
		_pMaze[x][y]._x = x;
		_pMaze[x][y]._y = y;
		_pMaze[x][y]._val = val;
		for (int i = 0; i < WAY_NUM; ++i)
		{
			_pMaze[x][y]._state[i] = NO;
		}
	}

	void setNodeState()//设置迷宫行走状态 
	{
		for (int i = 0; i < _row; ++i)
		{
			for (int j = 0; j < _col; ++j)
			{
				if (_pMaze[i][j]._val == 1)
				{
					continue;
				}

				if (j < _col - 1 && _pMaze[i][j + 1]._val == 0)
				{
					_pMaze[i][j]._state[RIGHT] = YES;
				}

				if (i < _row - 1 && _pMaze[i + 1][j]._val == 0)
				{
					_pMaze[i][j]._state[DOWN] = YES;
				}

				if (j > 0 && _pMaze[i][j - 1]._val == 0)
				{
					_pMaze[i][j]._state[LEFT] = YES;
				}

				if (i > 0 && _pMaze[i - 1][j]._val == 0)
				{
					_pMaze[i][j]._state[UP] = YES;
				}
			}
		}
	}

	void searchMazePath()//广度优先遍历搜索 
	{
		if (_pMaze[0][0]._val == 1)
		{
			return;
		}
		_queue.push(_pMaze[0][0]);//入口节点入队 

		while (!_queue.empty())//队列不为空 
		{
			Node front = _queue.front();//获取队头元素 
			int x = front._x;
			int y = front._y;

			//右方向
			if (_pMaze[x][y]._state[RIGHT] == YES)
			{
				_pMaze[x][y]._state[RIGHT] = NO;
				_pMaze[x][y + 1]._state[LEFT] = NO;
				//在辅助数组中记录一下节点的行走信息
				_pPath[x*_row + y + 1] = _pMaze[x][y];
				_queue.push(_pMaze[x][y + 1]);
				if (check(_pMaze[x][y + 1]))
					return;
			}

			//下方向
			if (_pMaze[x][y]._state[DOWN] == YES)
			{
				_pMaze[x][y]._state[DOWN] = NO;
				_pMaze[x + 1][y]._state[UP] = NO;
				_pPath[(x + 1)*_row + y] = _pMaze[x][y];
				_queue.push(_pMaze[x + 1][y]);
				if (check(_pMaze[x + 1][y]))
					return;
			}

			//左方向
			if (_pMaze[x][y]._state[LEFT] == YES)
			{
				_pMaze[x][y]._state[LEFT] = NO;
				_pMaze[x][y - 1]._state[RIGHT] = NO;
				_pPath[x*_row + y - 1] = _pMaze[x][y];
				_queue.push(_pMaze[x][y - 1]);
				if (check(_pMaze[x][y - 1]))
					return;
			}

			//上方向
			if (_pMaze[x][y]._state[UP] == YES)
			{
				_pMaze[x][y]._state[UP] = NO;
				_pMaze[x - 1][y]._state[DOWN] = NO;
				_pPath[(x - 1)*_row + y] = _pMaze[x][y];
				_queue.push(_pMaze[x - 1][y]);
				if (check(_pMaze[x - 1][y]))
					return;
			}

			//当前节点出队列
			_queue.pop();
		}
	}

	void showMazePath()//打印迷宫 
	{
		if (_queue.empty())
		{
			cout << "不存在一条迷宫路径！" << endl;
		}
		else
		{
			//回溯寻找迷宫路径节点
			int x = _row - 1;
			int y = _col - 1;
			for (;;)
			{
				_pMaze[x][y]._val = '*';
				if (x == 0 && y == 0)
					break;
				Node node = _pPath[x*_row + y];
				x = node._x;
				y = node._y;
			}

			for (int i = 0; i < _row; ++i)
			{
				for (int j = 0; j < _col; ++j)
				{
					if (_pMaze[i][j]._val == '*')
					{
						cout << "* ";
					}
					else
					{
						cout << _pMaze[i][j]._val << " ";
					}
				}
				cout << endl;
			}
		}
	}
private:
	//定义迷宫节点路径信息
	struct Node
	{
		int _x;
		int _y;
		int _val;//节点的值
		int _state[WAY_NUM];//记录节点四个方向的状态
	};

	//检查是否是右下角的迷宫出口节点
	bool check(Node &node)
	{
		return node._x == _row - 1 && node._y == _col - 1;
	}

	Node **_pMaze;//动态开辟二维数组 
	int _row;//行 
	int _col;//列 
	queue<Node> _queue;//广度遍历依赖的队列结构
	vector<Node> _pPath;//记录广度优先遍历时，节点的行走信息，辅助数组 
};

int main()
{
	cout << "请输入迷宫的行列数(例如：10 10):";
	int row, col, data;
	cin >> row >> col;

	Maze maze(row, col);//创建迷宫对象

	cout << "请输入迷宫的路径信息(0表示可以走，1表示不能走):" << endl;
	for (int i = 0; i < row; ++i)
	{
		for (int j = 0; j < col; ++j)
		{
			cin >> data;
			//可以初始化迷宫节点的基本信息
			maze.initNode(i, j, data);
		}
	}

	//开始设置所有节点的四个方向的状态
	maze.setNodeState();

	//开始从左上角搜索迷宫的路径信息了
	maze.searchMazePath();

	//打印迷宫路径搜索的结果
	maze.showMazePath();

	return 0;
}

Afison
关注
专栏目录
C++深度优先搜索迷宫（加强版）
PanDaoxi
10-31 462
C++深度优先搜索迷宫！
深度遍历迷宫搜索C++实现
weixin_42226134的博客
04-09 887
// 深度遍历迷宫路径搜索.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include "pch.h" #include <iostream> #include <stack> using namespace std; #if 0 /* 深度遍历搜索迷宫路径，软件运行要求如下： 请输入迷宫的行列数(例如：10 10):5 5 请输...
c++ 深搜 迷宫
10-26
c++ 深度搜索 迷宫问题 在一个n*n的方格中，1表示墙，0表示通路。利用深度搜索遍历。
迷宫求解路径C++版
CS_W98的博客
01-04 3320
题目1、问题描述： 以一个m×n的长方阵表示迷宫,0和1分别表示迷宫中的道路和障碍.设计一个程序,对任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论. 2、基本要求： 首先实现一个以链表做存储结构的栈类型,然后编写一个求解迷宫的非递归程序.求得的通路以三元组(i,j,d)的形式输出,其中:(i,j)指示迷宫中的一个坐标,d表示走到下一坐标的方向.如:对于下列数据的迷宫,输出的一条
【迷宫问题】找出迷宫所有可能的路径C++
最新发布
六根胡子
05-13 1707
用栈实现迷宫问题，找出所有可达的路径。
入门C/C++小游戏--迷宫
04-14
1. **C/C++语言基础**：在编写迷宫游戏之前，需要掌握C/C++的基本语法，包括变量声明、条件语句（if/else）、循环语句（for/while）、函数定义等。此外，了解指针的概念及其在内存管理中的作用也是必不可少的。 2. ...
迷宫问题.docx(C/C++)-期末实验报告/课程设计
12-29
《迷宫问题——C/C++实现与数据结构分析》 迷宫问题是一个经典的计算机科学问题，它涉及到数据结构的设计和算法的应用。在这个问题中，我们需要设计一种数据结构来表示迷宫，然后找到从入口到出口的路径。以下是...
C/C++:利用队列实现迷宫问题求解.rar(含完整注释)
03-04
在IT领域，迷宫问题是一个经典的算法问题，它通常涉及到路径搜索和图遍历。本教程将详细讨论如何使用C/C++编程语言，通过数据结构中的队列来解决这一问题。队列是一种先进先出（FIFO）的数据结构，非常适合进行广度...
使用C/C++语言生成一个随机迷宫游戏
08-31
在本文中，我们将探讨如何使用C/C++语言生成一个随机迷宫游戏。迷宫游戏是一种经典的逻辑思维挑战，它要求玩家找到从起点到终点的路径。以下是如何利用C/C++来实现这一目标的关键知识点。 首先，我们需要理解迷宫的...
C/C++广度优先搜索模拟迷宫求解问题
翾的博客
05-05 3333
问题描述用一个字符类型的二维数组表示迷宫，数组中的每个元素表示一个小方格，‘0’代表通道，‘1’代表阻塞物。设计一个模拟小动物走迷宫的程序，为小动物寻找一条从迷宫入口到迷宫出口的通路。功能及界面要求： 用户可以设置迷宫的行数或列数。 随机产生迷宫的状态。 用户设置小动物的入口下标和出口下标 根据迷宫状态和入、出口位置直观显示出从入口到出口的通路或“不存在通路”的信息。 代码重要的点已经注释了, 就不
迷宫求解c++ 最简路径
04-23
c++ 迷宫求解 简化路径 八方向查找 用文件实现 采用了栈 可以自己输入生成迷宫 还可以从文件中读取迷宫
C++迷宫最短路径
02-21
Eclipse下C++迷宫最短路径骨干程序,不完整
[C++] DFS-迷宫问题全部路径
szdytom的博客
02-17 3092
文章目录
C++深度优先搜索迷宫（普通版）
PanDaoxi
10-31 470
C++深度优先搜索迷宫！
c++ 使用广度优先算法走迷宫并标记路径
weixin_33973600的博客
01-13 216
2019独角兽企业重金招聘Python工程师标准>>> ...
c++迷宫小游戏
weixin_34248705的博客
05-08 1776
c++迷宫小游戏 一、总结 一句话总结： 显示：根据map数组输出图像 走动：修改map数组的值，每走一步重新刷新一下图像就好 1、如果走函数用z()，出现输入s会向下走多步的情况，原因是什么？ 向下走两层循环ij增加，而向下走i也是增加的，所以break跳出j后，照样找到i不误，所以会一直走到不能走为止 //走动函数 void z(){ char c=ge...
洛谷P1605 迷宫——S.B.S.
a394121312的博客
04-27 191
题目背景 迷宫 【问题描述】 给定一个N*M方格的迷宫，迷宫里有T处障碍，障碍处不可通过。给定起点坐标和 终点坐标，问: 每个方格最多经过1次，有多少种从起点坐标到终点坐标的方案。在迷宫 中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。 输入样例 输出样例 【数据规模】 1≤N,M≤5 题目描述 输入输出格式 输入格式： 【输入...
算法－DFS深度优先搜索解决迷宫问题（C++）
了解➔熟悉➔掌握➔精通
01-08 965
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net /* * 问题：求解迷宫问题。 * * 分析： * 方法：DFS深度优先搜索。 * 求解思路： * 1、先判断是否到达目标位置，如果到达目标位置，再试探有无其他更短的路径。 * 2、如果没有到达目标位置，则找到下一步可以到达的位置，直到找到目标位置。 * 注：从某点出发，沿着一个方向往下试探，当找到目标位置，还需回溯，以便找到所有的路径，再比
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值