C++ 深度优先搜索实现迷宫求解

本文介绍如何使用 C++ 实现一个简单的迷宫求解器，基于深度优先搜索（DFS）算法。该迷宫求解程序会从迷宫的起点出发，尝试找到通向终点的一条路径。

迷宫描述

我们使用一个 10x10 的二维数组来表示迷宫，其中：

• 1 表示墙壁，无法通过。
• 0 表示可以走的路。
• 3 表示已经走过的路径。

迷宫图如下（1 为墙壁，0 为可走区域）：

int maze[10][10] = {
    {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
    {1, 0, 0, 0, 0, 0, 0, 0, 0, 1},
    {1, 0, 1, 1, 1, 1, 0, 1, 0, 1},
    {1, 0, 0, 0, 0, 0, 0, 1, 0, 1},
    {1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
    {1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
    {1, 0, 1, 0, 0, 1, 0, 1, 1, 1},
    {1, 0, 1, 0, 0, 0, 0, 0, 0, 1},
    {1, 0, 1, 1, 1, 1, 1, 1, 0, 1},
    {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
};

深度优先搜索算法（DFS）

深度优先搜索是一种通过递归的方法遍历或查找图中的路径。在迷宫中，DFS 会从起点开始，尝试向四个方向移动（上下左右），当遇到障碍或无法前进时，回退到上一步，继续尝试其他路径，直到找到出口。

代码实现

以下是实现迷宫求解器的完整代码：

#include<iostream>
using namespace std;

// 定义四个方向的偏移量，分别为上下左右
int fx[4] = { 0, 1, 0, -1 }; 
int fy[4] = { 1, 0, -1, 0 };  

// 定义迷宫，1表示墙壁，0表示可走的路
int maze[10][10] = {
    {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
    {1, 0, 0, 0, 0, 0, 0, 0, 0, 1},
    {1, 0, 1, 1, 1, 1, 0, 1, 0, 1},
    {1, 0, 0, 0, 0, 0, 0, 1, 0, 1},
    {1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
    {1, 0, 1, 0, 0, 1, 0, 1, 0, 1},
    {1, 0, 1, 0, 0, 1, 0, 1, 1, 1},
    {1, 0, 1, 0, 0, 0, 0, 0, 0, 1},
    {1, 0, 1, 1, 1, 1, 1, 1, 0, 1},
    {1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
};

int nextx, nexty;

// 打印迷宫当前状态
void printMaze() {
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            if (maze[i][j] == 1) {
                cout << "1 ";  // 墙壁
            }
            else if (maze[i][j] == 0) {
                cout << "0 ";  // 可走的路
            }
            else if (maze[i][j] == 3) {
                cout << "3 ";  // 走过的路径
            }
        }
        cout << endl;
    }
    cout << endl;
}

// 深度优先搜索算法
bool mazesearch(int x, int y) {
    if (x == 8 && y == 8) {  // 如果到达终点
        cout << "路走完" << endl;
        return true;  
    }

    // 尝试向四个方向移动
    for (int i = 0; i < 4; i++) {
        nextx = x + fx[i];
        nexty = y + fy[i];

        // 判断是否可以走
        if (maze[nextx][nexty] == 0) {
            maze[nextx][nexty] = 3;  // 标记为走过的路径

            // 递归继续搜索
            if (mazesearch(nextx, nexty)) {
                return true;  // 找到出口，返回
            }

            maze[nextx][nexty] = 0;  // 如果该路径不通，回退，恢复原状态
        }
    }

    return false;  // 没有找到路径
}

int main() {
    maze[1][1] = 3;  // 设置起点
    if (mazesearch(1, 1)) {
        cout << "找到了一条路径！" << endl;
    }
    else {
        cout << "未找到路径。" << endl;
    }
    printMaze();  // 打印迷宫最终状态
    return 0;
}

代码详解：

1. 迷宫表示：我们使用二维数组 maze[10][10] 表示迷宫，其中 1 代表墙壁，0 代表可以走的路，3 代表已经走过的路径。
2. 方向数组：fx 和 fy 数组定义了可以移动的四个方向，分别是右、下、左、上。
3. 递归搜索：mazesearch 函数通过递归的方式，尝试在每个方向上寻找出口。如果某条路径不通，则回溯并尝试其他方向。
4. 终点检测：当搜索到 (8, 8) 时，表示成功找到出口，终止递归并输出结果。
5. 输出结果：程序运行结束后，打印最终的迷宫状态，其中 3 表示走过的路径。

代码详解：

1. 迷宫表示：我们使用二维数组 maze[10][10] 表示迷宫，其中 1 代表墙壁，0 代表可以走的路，3 代表已经走过的路径。
2. 方向数组：fx 和 fy 数组定义了可以移动的四个方向，分别是右、下、左、上。
3. 递归搜索：mazesearch 函数通过递归的方式，尝试在每个方向上寻找出口。如果某条路径不通，则回溯并尝试其他方向。
4. 终点检测：当搜索到 (8, 8) 时，表示成功找到出口，终止递归并输出结果。
5. 输出结果：程序运行结束后，打印最终的迷宫状态，其中 3 表示走过的路径。

运行结果示例：

在运行程序后，可能得到如下输出：