好的，以下是一个基于深度优先搜索
算法的
迷宫问题解法的代码
实现，包括添加显示
迷宫、
求解一条
迷宫路径、
求解所有
迷宫路径、
求解最短
迷宫路径等功能：
```
c++
#include <iostream>
#include <vector>
#include <stack>
#include <queue>
using namespace std;
// 定义
迷宫结构体
struct Maze {
int row; //
迷宫行数
int col; //
迷宫列数
vector<vector<int>> maze; // 二维
迷宫数组
};
// 定义坐标结构体
struct Pos {
int x;
int y;
};
// 添加
迷宫函数
void AddMaze(Maze& maze) {
cout << "请输入
迷宫的行数和列数: ";
cin >> maze.row >> maze.col;
// 初始化
迷宫为全部为墙
vector<vector<int>> mz(maze.row, vector<int>(maze.col, -1));
maze.maze = mz;
// 添加
迷宫地图
cout << "请输入
迷宫地图(0代表通路，1代表障碍): " << endl;
for (int i = 0; i < maze.row; i++) {
for (int j = 0; j < maze.col; j++) {
cin >> maze.maze[i][j];
}
}
}
// 显示
迷宫函数
void ShowMaze(Maze& maze) {
cout << "当前
迷宫地图如下: " << endl;
for (int i = 0; i < maze.row; i++) {
for (int j = 0; j < maze.col; j++) {
cout << maze.maze[i][j] << " ";
}
cout << endl;
}
}
// 判断当前位置是否合法
bool IsValidPos(Maze& maze, Pos& pos) {
if (pos.x < 0 || pos.x >= maze.row) {
return false;
}
if (pos.y < 0 || pos.y >= maze.col) {
return false;
}
if (maze.maze[pos.x][pos.y] == 1) {
return false;
}
return true;
}
// 深度优先搜索
求解一条
迷宫路径
bool
DFS(Maze& maze, Pos& start, Pos& end, vector<Pos>& path, vector<vector<int>>& visited) {
// 如果当前位置为终点，则返回true
if (start.x == end.x && start.y == end.y) {
path.push_back(start);
return true;
}
// 如果当前位置不合法，则返回false
if (!IsValidPos(maze, start)) {
return false;
}
// 如果当前位置已被访问过，则返回false
if (visited[start.x][start.y] == 1) {
return false;
}
// 将当前位置标记为已访问
visited[start.x][start.y] = 1;
// 将当前位置添加到
路径中
path.push_back(start);
// 分别向上、下、左、右四个
方向搜索
Pos next;
next.x = start.x - 1;
next.y = start.y;
if (
DFS(maze, next, end, path, visited)) {
return true;
}
next.x = start.x + 1;
next.y = start.y;
if (
DFS(maze, next, end, path, visited)) {
return true;
}
next.x = start.x;
next.y = start.y - 1;
if (
DFS(maze, next, end, path, visited)) {
return true;
}
next.x = start.x;
next.y = start.y + 1;
if (
DFS(maze, next, end, path, visited)) {
return true;
}
// 如果四个
方向都搜索不到终点，则将当前位置从
路径中删除
path.pop_back();
return false;
}
//
求解一条
迷宫路径函数
void SolveOnePath(Maze& maze, Pos& start, Pos& end) {
vector<Pos> path;
vector<vector<int>> visited(maze.row, vector<int>(maze.col, 0));
// 深度优先搜索
求解一条
迷宫路径
if (
DFS(maze, start, end, path, visited)) {
cout << "
迷宫路径如下: " << endl;
for (int i = 0; i < path.size(); i++) {
cout << "(" << path[i].x << "," << path[i].y << ") ";
}
cout << endl;
}
else {
cout << "没有找到
迷宫路径！" << endl;
}
}
//
求解所有
迷宫路径函数
void SolveAllPaths(Maze& maze, Pos& start, Pos& end) {
stack<Pos> s;
vector<vector<int>> visited(maze.row, vector<int>(maze.col, 0));
s.push(start);
cout << "所有
迷宫路径如下: " << endl;
while (!s.empty()) {
Pos cur = s.top();
s.pop();
// 如果当前位置为终点，则输出
路径
if (cur.x == end.x && cur.y == end.y) {
cout << "(" << start.x << "," << start.y << ") ";
stack<Pos> temp;
while (!s.empty()) {
temp.push(s.top());
s.pop();
}
while (!temp.empty()) {
cout << "(" << temp.top().x << "," << temp.top().y << ") ";
s.push(temp.top());
temp.pop();
}
cout << "(" << end.x << "," << end.y << ")" << endl;
continue;
}
// 如果当前位置不合法，则跳过
if (!IsValidPos(maze, cur)) {
continue;
}
// 如果当前位置已被访问过，则跳过
if (visited[cur.x][cur.y] == 1) {
continue;
}
// 将当前位置标记为已访问，并加入
路径
visited[cur.x][cur.y] = 1;
s.push(cur);
// 分别向上、下、左、右四个
方向搜索
Pos next;
next.x = cur.x - 1;
next.y = cur.y;
s.push(next);
next.x = cur.x + 1;
next.y = cur.y;
s.push(next);
next.x = cur.x;
next.y = cur.y - 1;
s.push(next);
next.x = cur.x;
next.y = cur.y + 1;
s.push(next);
}
}
//
求解最短
迷宫路径函数
void SolveShortestPath(Maze& maze, Pos& start, Pos& end) {
queue<Pos> q;
vector<vector<int>> visited(maze.row, vector<int>(maze.col, 0));
vector<vector<int>> dist(maze.row, vector<int>(maze.col, 0));
q.push(start);
visited[start.x][start.y] = 1;
while (!q.empty()) {
Pos cur = q.front();
q.pop();
// 如果当前位置为终点，则输出
路径长度
if (cur.x == end.x && cur.y == end.y) {
cout << "最短
迷宫路径长度为: " << dist[cur.x][cur.y] << endl;
return;
}
// 分别向上、下、左、右四个
方向搜索
Pos next;
next.x = cur.x - 1;
next.y = cur.y;
if (IsValidPos(maze, next) && visited[next.x][next.y] == 0) {
visited[next.x][next.y] = 1;
dist[next.x][next.y] = dist[cur.x][cur.y] + 1;
q.push(next);
}
next.x = cur.x + 1;
next.y = cur.y;
if (IsValidPos(maze, next) && visited[next.x][next.y] == 0) {
visited[next.x][next.y] = 1;
dist[next.x][next.y] = dist[cur.x][cur.y] + 1;
q.push(next);
}
next.x = cur.x;
next.y = cur.y - 1;
if (IsValidPos(maze, next) && visited[next.x][next.y] == 0) {
visited[next.x][next.y] = 1;
dist[next.x][next.y] = dist[cur.x][cur.y] + 1;
q.push(next);
}
next.x = cur.x;
next.y = cur.y + 1;
if (IsValidPos(maze, next) && visited[next.x][next.y] == 0) {
visited[next.x][next.y] = 1;
dist[next.x][next.y] = dist[cur.x][cur.y] + 1;
q.push(next);
}
}
cout << "没有找到
迷宫路径！" << endl;
}
int main() {
Maze maze;
AddMaze(maze);
ShowMaze(maze);
Pos start, end;
cout << "请输入起点坐标: ";
cin >> start.x >> start.y;
cout << "请输入终点坐标: ";
cin >> end.x >> end.y;
SolveOnePath(maze, start, end);
SolveAllPaths(maze, start, end);
SolveShortestPath(maze, start, end);
return 0;
}
```
注意：以上代码仅供参考，可能存在一些细节问题，具体
实现可根据需要进行调整。
1234
非常没帮助
没帮助
一般
有帮助
非常有帮助
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
