迷宫的最短路径

最新推荐文章于 2023-02-21 17:51:37 发布

原创最新推荐文章于 2023-02-21 17:51:37 发布 · 1.6k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#BFS #最短路径 #迷宫 #DFS #算法

算法题专栏收录该内容

4 篇文章

订阅专栏

本文探讨如何解决迷宫的最短路径问题，利用BFS广度优先搜索算法进行遍历，确保从起点到终点的最小步数。在限制条件N, M ≤ 100的情况下，给出解题思路和代码实现，强调BFS算法避免了DFS的回溯，能有效记录从起点到各点的最短距离。" 96044885,8205309,Java实现函数依赖集闭包与属性闭包操作,"['函数依赖集闭包', '属性集闭包', 'java', '数据结构', '数据库理论']

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

==> 学习汇总（持续更新）
==> 从零搭建后端基础设施系列（一）-- 背景介绍

迷宫的最短路径
给定一个大小为 N×M 的迷宫。迷宫由通道和墙壁组成，每一步可以向邻接的上下左右四格
的通道移动。请求出从起点到终点所需的最小步数。请注意，本题假定从起点一定可以移动
到终点。
限制条件
 N, M ≤ 100

输入样例:

N=10, M=10（迷宫如下图所示。 '#'， '.'， 'S'， 'G'分别表示墙壁、通道、起点和终点）
#S######.#
......#..#
.#.##.##.#
.#........
##.##.####
....#....#
.#.#####.#
..........
.####.###.
........G#

输出：
16

解题思路: 用BFS广度优先算法遍历。因为这里只有四个方向可以动，所以就是递归的往这四个方向尽可能的移动，直到终点为止。

注： BFS算法不像DFS一条路走到黑，BFS是扩散性的，走到一个点，就会向四周进行扩散，一直到所求的点为止，其中走过的点会被标记，所以每个点只会走一遍。这样BFS的比DFS的好处就是，很方便的记录从起始点到各个点的最短距离了。下面会有距离向量矩阵。

代码：

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
#define INF 2<<29

typedef struct _point
{
	int x;
	int y;
}POINT;

//宽度优先搜索
int BFS(vector<vector<char> >& g, POINT& ptS, POINT& ptE)
{
	int n = g.size(), m = g[0].size();
	vector<vector<int> > dis(n);
	//初始化距离向量
	for (int i = 0;i < n;i++)
	{
		dis[i].resize(m);
		for (int j = 0;j < m;j++)
			dis[i][j] = INF;
	}
	POINT dt[4] = { {-1,0},{1,0},{0,-1},{0,1} }; //上下左右四个方向
	queue<POINT> q;
	//将起点入队
	q.push(ptS);
	dis[ptS.x][ptS.y] = 0;  //0表示已经走过了
	//若队列不为空或者没有到达终点，则继续遍历
	while (!q.empty())
	{
		//取出队头
		POINT pCur = q.front();
		q.pop();
		//如果到达终点就结束
		if(pCur.x == ptE.x&& pCur.y == ptE.y) break;
		//尝试往四个方向走
		for (int i = 0; i < 4; i++)
		{
			POINT p = { pCur.x + dt[i].x,pCur.y + dt[i].y};
			if (p.x >= 0 && p.x < n && p.y >= 0 && p.y < m && g[p.x][p.y] != '#' && dis[p.x][p.y] == INF)
			{
				//如果这个方向可以走，则将该点入队
				q.push(p);
				//距离+1
				dis[p.x][p.y] = dis[pCur.x][pCur.y] + 1;
			}
		}
	}
	return dis[ptE.x][ptE.y];
}

int main()
{
	int n = 0,m= 0;
	POINT ptS, ptE;
	cin >> n >> m;
	//输入
	vector<vector<char> > g(n);
	for (int i = 0;i<n;i++)
	{
		g[i].resize(m);
		for (int j = 0;j < m;j++)
		{
			cin >> g[i][j];
			if (g[i][j] == 'S')
				ptS = { i,j };
			else if (g[i][j] == 'G')
				ptE = { i,j };
		}
			
	}
	//输出
	cout << BFS(g, ptS, ptE) << endl;
	return 0;
}

距离向量：

#   0   #  	#  	#  	#  	#  	#  	13  #
2   1   2  	3  	4  	5  	#  	13  12  #
3   #   3  	#  	#  	6  	#  	#  	11  #
4   #   4  	5  	6  	7  	8  	9  	10  11
#   #   5  	#  	#  	8  	#  	#  	#  	#
8   7   6  	7  	#  	9  	10  11  12  #
9   #   7  	#  	#  	#  	#  	#  	13  #
10  9   8  	9  	10  11  12  13  14  15
11  #   #  	#  	#  	12  #  	#  	#  	16
12  13  14  15  14  13  14  15  16  #

这就是迷宫的可行路线，每个点的距离都会被记录下来。