在
C++中，使用
广度优先
搜索（
BFS）算法求解
走出
迷宫的最短
路径是一种常见且有效的方法。
BFS算法的核心思想是从起点开始，逐层扩展
搜索范围，直到找到终点。以下是实现该功能的详细步骤和示例代码：
### 思路
- 首先创建一个空的队列，将起点加入队列。
- 从起点开始访问，然后访问起点周围的相邻点。
- 判断这些相邻点的状态，如果是未访问过且可通行的点，则将该点加入队列。
- 不断重复上述过程，直到访问到终点，此时
记录的
路径即为最短
路径；或者直到队列为空，说明没有找到可行
路径，输出相应提示信息。
### 示例代码
```cpp
#include <
iostream>
#include <queue>
#include <vector>
using namespace std;
// 定义方向数组，分别表示上、下、左、右
const int dx[] = {-1, 1, 0, 0};
const int dy[] = {0, 0, -1, 1};
// 定义点的结构体
struct Point {
int x, y;
Point(int _x, int _y) : x(_x), y(_y) {}
};
// 检查点是否在
迷宫范围内且可通行
bool isValid(int x, int y, int rows, int cols, const vector<vector<int>>& maze) {
return x >= 0 && x < rows && y >= 0 && y < cols && maze[x][y] == 0;
}
//
BFS函数求解最短
路径
int
bfs(const vector<vector<int>>& maze, Point start, Point end) {
int rows = maze.size();
int cols = maze[0].size();
vector<vector<bool>> visited(rows, vector<bool>(cols, false));
queue<pair<Point, int>> q;
q.push({start, 0});
visited[start.x][start.y] = true;
while (!q.empty()) {
auto [current, dist] = q.front();
q.pop();
if (current.x == end.x && current.y == end.y) {
return dist;
}
for (int i = 0; i < 4; ++i) {
int newX = current.x + dx[i];
int newY = current.y + dy[i];
if (isValid(newX, newY, rows, cols, maze) && !visited[newX][newY]) {
q.push({Point(newX, newY), dist + 1});
visited[newX][newY] = true;
}
}
}
return -1; // 没有找到
路径
}
int main() {
vector<vector<int>> maze = {
{0, 1, 0, 0},
{0, 0, 0, 1},
{0, 1, 0, 0},
{0, 0, 1, 0}
};
Point start(0, 0);
Point end(3, 3);
int shortestPath =
bfs(maze, start, end);
if (shortestPath != -1) {
cout << "最短
路径长度: " << shortestPath << endl;
} else {
cout << "No Answer." << endl;
}
return 0;
}
```
### 代码解释
1. **方向数组**：`dx` 和 `dy` 数组用于表示上、下、左、右四个方向的偏移量。
2. **点的结构体**：`Point` 结构体用于表示
迷宫中的一个点，包含 `x` 和 `y` 坐标。
3. **检查点的有效性**：`isValid` 函数用于检查一个点是否在
迷宫范围内且可通行。
4. **
BFS函数**：`
bfs` 函数实现了
广度优先
搜索的核心逻辑，使用队列存储待访问的点，并使用 `visited` 数组
记录已访问的点。
5. **主函数**：在 `main` 函数中，定义了一个
迷宫矩阵，设置起点和终点，调用 `
bfs` 函数求解最短
路径，并输出结果。
### 复杂度分析
- **时间复杂度**：$O(m * n)$，其中 $m$ 和 $n$ 分别是
迷宫的行数和列数。因为每个点最多被访问一次。
- **空间复杂度**：$O(m * n)$，主要用于存储 `visited` 数组和队列。
本文介绍了一种使用广度优先搜索(BFS)解决迷宫寻路问题的方法。通过定义方向数组和边界检查函数，确保了算法的有效性和正确性。文章详细展示了如何从起点开始遍历至终点，并记录路径，最后逆向输出整个路径。
扫一扫
504
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
