前言

BFS广度优先搜索解决迷宫问题

迷宫问题

原题目：迷宫由n行m列的单元格组成(n,m都小于等于50)，每个单元格要吗是空地要吗是障碍物。现在请你找到一条从起点到终点的最短路径长度。

分析

首先我们将起点入队，
然后队首节点可拓展的点入队，如果没有可拓展的点，将队首节点出队。重复该步骤直到达到目标位置或者队列为空。

代码如下：

#include <bits/stdc++.h>
using namespace std;

const int MAX = 100; // 定义最大矩阵大小
int a[MAX][MAX], v[MAX][MAX]; // a 用于存储迷宫地图，v 用于记录访问状态

// 定义点结构体
struct point {
    int x;    // 点的 x 坐标
    int y;    // 点的 y 坐标
    int step; // 从起点到达该点的步数
};

queue<point> r; // 申请队列，用于 BFS 遍历
int dx[4] = {0, 1, 0, -1}; // 四个方向的 x 偏移量（右、下、左、上）
int dy[4] = {1, 0, -1, 0}; // 四个方向的 y 偏移量（右、下、左、上）
/*
5 4
1 1 0 1
1 1 1 1
1 1 0 1
1 0 1 1
1 1 1 0
1 1 4 3
*/
int main() {
    int n, m; // 迷宫的行数和列数
    int startx, starty; // 起点的坐标
    int endx, endy; // 终点的坐标

    // 读取迷宫的行数和列数
    cin >> n >> m;
    
    // 初始化 v 数组，所有点的访问状态都设为 0（未访问）
    for(int i = 0; i < MAX; i++) {
        for(int j = 0; j < MAX; j++) {
            v[i][j] = 0;
        }
    }
    
    // 读取迷宫地图
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            cin >> a[i][j];
        }
    }
    
    // 读取起点和终点的坐标
    cin >> startx >> starty >> endx >> endy;
    
    // 初始化 BFS 的起点
    point start;
    start.x = startx;
    start.y = starty;
    start.step = 0; // 起点的步数为 0
    r.push(start); // 将起点入队
    v[startx][starty] = 1; // 标记起点为已访问
    int flag = 0; // 标记是否找到路径

    // 开始 BFS 遍历
    while(!r.empty()) {
        int x = r.front().x; // 当前点的 x 坐标
        int y = r.front().y; // 当前点的 y 坐标
        int step = r.front().step; // 当前点的步数
        r.pop(); // 取出队首元素
        
        // 如果当前点是终点，输出步数并终止
        if(x == endx && y == endy) {
            flag = 1;
            cout << step << endl;
            break;
        }
        
        // 遍历四个方向
        for(int k = 0; k < 4; k++) {
            int tx = x + dx[k]; // 计算新点的 x 坐标
            int ty = y + dy[k]; // 计算新点的 y 坐标
            
            // 确保新点在合法范围内
            if(tx >= 1 && tx <= n && ty >= 1 && ty <= m) {
                // 如果新点是可通行的且未访问过
                if(a[tx][ty] == 1 && v[tx][ty] == 0) {
                    // 更新新点的坐标和步数
                    point temp;
                    temp.x = tx;
                    temp.y = ty;
                    temp.step = step + 1;
                    r.push(temp); // 将新点入队
                    v[tx][ty] = 1; // 标记新点为已访问
                }
            }
        }
    }
    
    // 如果没有找到路径，输出提示信息
    if(flag == 0) {
        cout << "没有路径" << endl;
    }
    
    return 0;
}

BFS和DFS的区别

广度优先搜索：将队首结点可以拓展的点入队，如果没有可以拓展的点，将队首结点出队。重复上述步骤，直到到达目标位置或者队列为空。BFS搜索到的结果一定是最短的。BFS运用到了队列。
深度优先搜索： (从某点出发，沿着一个方向往下试探，当找到目标位置，还需回溯，以便找到所有的路径，再比较最短的路径，比较盲目，效率没有BFS高。DFS运用到了栈。