迷宫（蓝桥杯）——DFS和BFS

news/2024/4/28 15:24:22

迷宫

题目描述

下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可以通行的地方。

010000
000100
001001
110000

迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。

对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中
D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），
请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。

请注意在字典序中 D<L<R<U。

01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000

暴力DFS

这段代码是一个迷宫求解程序，使用深度优先搜索（DFS）算法来找到从迷宫的左上角（起点）到右下角（终点）的最短路径。下面是对代码的详细注释：

#include<bits/stdc++.h>
using namespace std;// 定义列数和行数
const int col=30, row=50;// 迷宫的二维数组，0表示可通行，1表示障碍
int mp[col+1][row+1] = {// 迷宫的具体布局，这里省略了具体的数字，只给出了格式// ...
};// 用于记录路径的字符数组
char a[col*row];// 用于保存最终路径的字符串
string s;// 记录从起点到终点的最短步数
int best = INT_MAX;// 判断函数，用来判断当前坐标是否在迷宫内部且为可通行区域
int judge(int x, int y) {if (x > 0 && x <= col && y > 0 && y <= row && v[x][y] == 0 && mp[x][y] == 0)return 1;return 0;
}// 深度优先搜索函数，用于寻找路径
void dfs(int x, int y, int step) {// 如果当前步数已经超过已知的最短步数，则直接返回if (step > best)return;// 如果已经到达终点（迷宫的右下角），则记录路径if (x == col && y == row) {string temp;// 将路径中的每一步转换为字符串形式并拼接for (int i = 0; i < step; i++)temp += a[i];// 如果当前路径比已知的最短路径更短，则更新最短路径if (step < best) {best = step;s = temp;}// 如果当前路径与已知的最短路径同样短，但字典序更小，则更新最短路径else if (step == best && temp < s)s = temp;return;}// 定义四个可能的移动方向：上、下、左、右int dir_x[4] = {-1, 1, 0, 0};int dir_y[4] = {0, 0, -1, 1};char dir[4] = {'U', 'D', 'L', 'R'};// 遍历所有可能的移动方向for (int i = 0; i < 4; i++) {int x_1 = x + dir_x[i];int y_1 = y + dir_y[i];// 如果新的位置在迷宫内部且为可通行区域if (judge(x_1, y_1)) {// 记录当前方向到路径数组中a[step] = dir[i];// 标记当前位置为已访问v[x_1][y_1] = 1;// 递归调用dfs函数，继续搜索下一个位置dfs(x_1, y_1, step + 1);// 回溯，将当前位置标记为未访问v[x_1][y_1] = 0;}}
}int main() {// 将起点标记为已访问v[1][1] = 1;// 调用dfs函数开始搜索dfs(1, 1, 0);// 输出最终找到的最短路径cout << s << endl;// 输出最短路径的步数cout << best << endl;return 0;
}

这段代码的主要逻辑是通过深度优先搜索来遍历迷宫的所有可能路径，同时记录并更新最短路径。在搜索过程中，使用了一个二维数组 v 来标记已经访问过的位置，以避免重复访问。当到达终点时，会检查当前路径的步数是否比已知的最短路径更短，或者在步数相同的情况下是否字典序更小。如果满足条件，就会更新最短路径。最后，程序输出找到的最短路径及其步数。

因为dfs是遍历到每一条路径，所以代码编译时间一定很长，但这是填空题，所以暴力也是一种办法
在这里插入图片描述
所以，我们需要优化

这个方法好像不行，我运行4个小时也没出答案，应该是递归太多栈溢出了

DFS+剪枝优化

根据上面代码以及截图来看，如果我们定义一个mins数组来存储从起点到该点的位置，如果 pos+1 大于 mins[tox][toy]，那么当前路径不会是到达 (tox, toy) 的最短路径，因此没有必要继续在这个方向上搜索，可以剪枝，节省搜索时间。

因此，我们只需要在if判断中加入pos+1<=mins[tox][toy]条件即可

if(judge(tox,toy)&&pos+1<=mins[tox][toy])//判断下一步是否合法且如果pos+1大于起点到（tox，toy）的步骤，依然无意义

代码详细注释如下：

// 引入必要的头文件
#include<iostream>
#include<cstring> // 用于 memset 函数
#include<string> // 用于 string 类型
using namespace std;// 定义四个可能的移动方向：右（R）、左（L）、下（D）、上（U）
const int dirx[4] = {0, 0, 1, -1}; // x 坐标的变动
const int diry[4] = {1, -1, 0, 0}; // y 坐标的变动
const char dir[4] = {'R', 'L', 'D', 'U'}; // 方向的缩写// 定义迷宫的行数和列数
const int row = 30, col = 50;// 定义一个字符数组，用于记录最终的路径序列
char a[row * col + 5];// 定义一个字符串，用于存储最终的路径序列
string ans;// 定义迷宫数组，0 表示可通行，1 表示障碍
int maze[row + 1][col + 1] = {// 迷宫的具体布局，这里省略了具体的数字，只给出了格式// ...
};// 判断函数，用于检查坐标 (x, y) 是否在迷宫内部且为可通行区域
int judge(int x, int y) {if (x > 0 && x <= row && y > 0 && y <= col && maze[x][y] == 0)return 1;return 0;
}// 深度优先搜索函数，用于寻找通往出口的最短路径
void dfs(int x, int y, int pos) {// 如果当前步数已经超过已知的最短步数 best，则直接返回if (pos > best)return;// 如果已经到达终点（迷宫的右下角），则记录路径if (x == row && y == col) {// 根据路径记录构建字符串string temp;for (i = 0; i < pos; i++) {temp += a[i];}// 如果当前路径比已知的最短路径更短，则更新 best 和 ansif (pos < best) {ans = temp;best = pos;} else if (pos == best && temp < ans) {ans = temp;}return;}// 遍历四个可能的移动方向for (int i = 0; i < 4; i++) {int tox = x + dirx[i];int toy = y + diry[i];// 如果新的位置在迷宫内部且为可通行区域if (judge(tox, toy)) {// 标记当前位置为已访问maze[tox][toy] = 1;// 更新到新位置的最短步数mins[tox][toy] = pos + 1;// 记录移动方向到路径数组中a[pos] = dir[i];// 递归调用 dfs 函数，继续搜索下一个位置dfs(tox, toy, pos + 1);// 回溯，将当前位置标记为未访问maze[tox][toy] = 0;}}
}// 主函数
int main() {// 初始化 mins 数组，将所有值设置为一个非常大的数，表示无穷大memset(mins, 1, sizeof(mins));// 初始化 best 为一个非常大的数，用于记录从起点到终点的最小步数best = 1 << 28;// 将迷宫入口（1, 1）标记为已访问maze[1][1] = 1;// 调用 dfs 函数开始搜索dfs(1, 1, 0);// 输出最终找到的最短路径cout << ans << endl;// 输出最短路径的步数cout << best << endl;return 0;
}

这段代码的主要逻辑是通过深度优先搜索来遍历迷宫的所有可能路径，同时记录并更新最短路径。在搜索过程中，使用了一个二维数组 mins 来记录从起点到每个点的最短步数，以及一个字符数组 a 来记录路径中的每一步移动方向。当到达终点时，会检查当前路径的步数是否比已知的最短路径更短，或者在步数相同的情况下是否字典序更小。如果满足条件，就会更新最短路径。最后，程序输出找到的最短路径及其步数。

难点解释：pos+1<=mins[tox][toy]

在这段代码中，pos+1<=mins[tox][toy] 这一行的作用是检查当前扩展的路径是否可能成为到达新位置 (tox, toy) 的更短或等长但字典序更优的路径。

具体来说，这里的 pos 表示当前路径的步数，mins[tox][toy] 存储的是到达位置 (tox, toy) 的最短步数。如果 pos+1（即当前路径步数加一，因为我们要移动到新位置）小于或等于 mins[tox][toy]，这意味着我们找到了一个到达该位置的路径，其步数不比已知的最短步数多，或者步数相同时路径的字典序更优（因为在这段代码中，路径是通过字符数组 a 记录的，所以可以直接比较字符串的字典序）。

如果 pos+1 大于 mins[tox][toy]，那么当前路径不会是到达 (tox, toy) 的最短路径，因此没有必要继续在这个方向上搜索，可以剪枝，节省搜索时间。

这个条件检查是典型的在图搜索算法中用于优化和剪枝的技巧，它帮助算法避免在不可能改善当前最短路径的方向上浪费时间。通过这种方式，算法可以保证在找到出口时，记录的路径是最短的，并且在步数相同时字典序最小的路径。

踩过的坑：memset(mins, 1, sizeof(mins));

这里我没理解memset函数的作用，其实memset这个函数只能将整型数组初始化为0和-1，对于其他数字的初始化则不行，例如这里memset(mins, 1, sizeof(mins));则是将mins数组初始化为16843009，这是一个非常大的数

BFS

#include<bits/stdc++.h> // 包含所有标准库
using namespace std;
typedef pair<int,int> PII; // 定义一个类型别名，方便表示坐标对const int col=30,row=50; // 定义迷宫的列数和行数// 迷宫的布局，0表示可通行的路径，1表示障碍
int mp[col][row] = {
0,1,0,1,0,1,0,1,0,0,1,0,1,1,0,0,1,0,0,1,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,
0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1,0,1,0,0,1,0,1,
0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,1,0,0,0,0,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,
0,1,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,0,0,1,0,1,1,
0,0,0,1,1,1,1,1,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,
1,1,0,0,1,0,0,0,1,1,0,1,0,1,0,0,0,0,1,0,1,0,1,1,0,0,0,1,1,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,0,1,1,1,
0,0,0,1,1,0,1,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,1,0,0,0,0,0,0,0,
1,0,1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,1,1,0,1,0,1,0,1,0,1,1,1,1,1,0,0,1,1,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,
0,0,1,1,1,0,0,0,0,0,1,0,1,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,1,1,0,0,0,0,1,0,0,1,
1,1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,1,0,1,0,0,0,
0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,0,1,0,1,
1,1,1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,0,1,0,1,0,0,
0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,1,0,0,1,1,1,1,0,1,0,0,0,1,1,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,1,1,
1,0,1,0,1,0,1,0,0,1,1,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,1,0,1,1,0,0,1,1,1,1,0,1,1,0,1,0,0,0,0,1,0,0,0,
1,0,1,0,1,0,1,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,1,1,0,1,1,1,0,1,0,0,1,
1,0,0,0,0,0,0,0,1,0,1,1,0,0,0,1,0,0,0,0,1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,
1,0,1,0,1,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,1,1,1,1,0,1,0,1,0,0,1,
0,0,1,0,1,0,0,1,0,1,0,1,0,1,1,0,1,0,0,1,0,1,0,1,0,0,0,1,1,0,1,0,1,0,1,1,0,1,1,1,0,0,0,0,1,1,0,1,0,1,
1,1,0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,1,0,
0,0,0,0,1,0,0,0,1,1,0,0,0,0,1,1,0,1,0,1,1,0,1,0,0,0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,
1,0,1,0,0,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,1,0,1,1,0,1,0,1,1,0,1,0,1,0,1,0,0,0,0,1,
0,0,1,0,1,0,0,0,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,
1,0,1,0,0,0,0,1,0,0,0,1,1,0,0,1,0,0,0,1,0,0,0,0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,0,1,1,1,1,1,0,1,0,0,1,0,
0,0,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,1,1,0,0,1,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,
1,1,0,1,0,0,0,0,0,0,1,0,0,1,1,1,0,1,1,1,0,0,1,0,0,1,0,0,0,0,1,1,1,0,1,0,0,1,0,1,1,0,1,1,1,0,1,0,0,0,
0,0,0,0,0,1,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,1,0,1,0,0,0,0,0,0,1,1,0,0,1,1,
1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,1,1,1,1,0,0,0,1,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,
1,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0,0,0,
0,0,1,1,1,1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,1,1,
1,0,0,0,0,0,0,1,1,0,0,1,1,1,0,1,0,1,1,1,0,1,0,0,0,1,0,0,0,1,1,0,1,1,1,0,1,0,1,0,1,1,0,1,1,1,1,0,0,0
};int d[col+1][row+1]; // 定义一个二维数组，用于记录从起点到每个点的最短距离queue<PII> p; // 创建一个队列，用于存放待探索的坐标// 定义一个结构体，用于记录路径信息
struct node {int x; // 父节点的x坐标int y; // 父节点的y坐标char s; // 父节点的方向
};node fa[col][row]; // 创建一个二维数组，用于记录每个点的父节点信息// dx和dy数组用于表示四个方向的相对坐标变化
int dx[5] = {1, 0, 0, -1};
int dy[5] = {0, -1, 1, 0};// dir数组用于表示四个方向的字符，按照字典序排序
char dir[5] = {'D', 'L', 'R', 'U'};// 判断函数，用于检查坐标是否在迷宫内，且为可通行的路径，且未被探索过
int judge(int x, int y) {if (x >= 0 && x < col && y >= 0 && y < row && mp[x][y] == 0 && d[x][y] == -1)return 1;return 0;
}// 深度优先搜索函数，用于探索迷宫
void dfs(int x, int y) {if (x == col - 1 && y == row - 1) // 如果到达终点，则停止搜索return;elsedfs(fa[x][y].x, fa[x][y].y); // 递归探索父节点//因为father(29,49)存储了它上一个位置在哪，那么就可以顺藤摸瓜的找出再上一个位置//如此搜索下去，直到搜到（0，0）位置而终止，返回上一层打印出所记录的direction方位，//逐层返回，就把从（0，0）走到（29，49）所途径的所有点时的direction都打印出来了cout << fa[x][y].s; // 输出路径
}int main() {memset(d, -1, sizeof(d)); // 初始化距离数组，将所有值设为-1，表示未探索p.push({0, 0}); // 将起点加入队列d[0][0] = 0; // 起点到起点的距离设为0while (p.size() != 0) { // 当队列不为空时，循环探索PII t = p.front(); // 取出队列中的第一个元素p.pop();for (int i = 0; i < 4; i++) { // 遍历四个方向int tx = t.first + dx[i]; // 计算目标坐标int ty = t.second + dy[i];if (judge(tx, ty)) { // 如果目标坐标可通行d[tx][ty] = d[t.first][t.second] + 1; // 更新距离p.push({tx, ty}); // 将目标坐标加入队列fa[tx][ty].x = t.first; // 记录父节点坐标fa[tx][ty].y = t.second;fa[tx][ty].s = dir[i]; // 记录方向//father(tox,toy)的x、y、s表明了//走到（tox，toy）这个点，是从其（x，y）点往s方向而来的 //换句话说，就是存储了它的上一个点的位置，以及从何方位而来 }}}dfs(col - 1, row - 1); // 从终点开始回溯，输出路径return 0;
}

这段代码的主要功能是找到从迷宫的左上角（起点）到右下角（终点）的最短路径，并按照字典序输出路径。代码使用了深度优先搜索算法，通过一个队列来实现层级遍历，同时记录每个点的父节点信息，以便最后回溯输出路径。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.cpky.cn/p/10892.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈，一经查实，立即删除！

相关文章

Prompt提示工程上手指南:基础原理及实践(三)-Prompt个性知识库引导

Prompt提示工程上手指南:基础原理及实践(三)-Prompt个性知识库引导

前言 Prompt系列的第二期文章已经将所有的Prompt工程主流策略讲解完毕&#xff0c;共涉及到六种Prompt类别模型以及具体生产内容详解。再结合系列第一篇文章具体对Prompt工程的详细介绍&#xff0c;也就可以达到Prompt工程师的初步入门&#xff0c;现在如果掌握了这些基础技能…
阅读更多...
Odoo17免费开源ERP开发技巧：如何在表单视图中调用JS类

Odoo17免费开源ERP开发技巧：如何在表单视图中调用JS类

文/Odoo亚太金牌服务开源智造 老杨 在Odoo最新V17新版中&#xff0c;其突出功能之一是能够构建个性化视图&#xff0c;允许用户以独特的方式与数据互动。本文深入探讨了如何使用 JavaScript 类来呈现表单视图来创建自定义视图。通过学习本教程&#xff0c;你将获得关于开发Odo…
阅读更多...
数据机构-2（顺序表）

数据机构-2（顺序表）

线性表 概念 顺序表 示例&#xff1a;创建一个存储学生信息的顺序表 表头&#xff08;Tlen总长度&#xff0c; Clen当前长度&#xff09; 函数 #include <seqlist.c> #include <stdio.h> #include <stdlib.h> #include "seqlist.h" #include &…
阅读更多...
WPF连接MySqldemo

WPF连接MySqldemo

界面总要管理数据嘛,于是便学习了一下WPF与MySql的基本连接. 运行结果: 环境配置 需要下载安装Mysql,网上教程很多,不详说,创建的工程需要下载或者引入相关的包(MySql.Data) 连接的部分直接看具体的代码即可 xaml代码(只放置了一个按钮和文本框) <Grid><Button x:Name…
阅读更多...
小程序云开发实战：通用企业产品信息展示小程序

小程序云开发实战：通用企业产品信息展示小程序

之前做小程序都是自己搭建数据管理后台&#xff0c;比如我之前做的小程序&#xff1a;一搜就学&#xff0c;就是使用java来做管理后台&#xff0c;小程序做前端展示。但是对于简单的小程序来说&#xff0c;做一套管理后台有点拿大炮打蚊子&#xff0c;所以使用云开发就是不错的…
阅读更多...
爬虫逆向实战(37)-某保险超市(AES，SHA256)

爬虫逆向实战(37)-某保险超市(AES，SHA256)

一、数据接口分析 主页地址&#xff1a;某保险超市 1、抓包 通过抓包可以发现数据接口是/tacpc/tiananapp/marketing_product_commodity/commodityList 2、判断是否有加密参数 请求参数是否加密&#xff1f; 通过查看“载荷”模块可以发现&#xff0c;有一个jsonKey加密参…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站 广利置业