迷宫（蓝桥杯）—

迷宫

题目描述

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

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

对于上面的迷宫，从入口开始，可以按 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 和 ans
        if (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;
    else
        dfs(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; // 起点到起点的距离设为0

    while (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;
}

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