迷宫（BFS）

#include <iostream>
#include <cstring>
#include <queue>  // 包含用于广度优先搜索的标准队列头文件
using namespace std;

const int N = 110;  // 定义迷宫的最大尺寸（110x110）

typedef pair<int, int> PII;  // 定义一个二维坐标对类型，方便表示迷宫中的位置（行、列）

int n, m;  // n 和 m 分别表示迷宫的行数和列数
int a, b;  // 起点的行和列
int c, h;  // 终点的行和列
int g[N][N];  // 二维数组 g 用于存储迷宫地图，其中 1 表示道路，0 表示障碍物
int d[N][N];  // 二维数组 d 用于记录从起点到每个点的最短距离

// 广度优先搜索（BFS）算法，用于求解迷宫的最短路径
int bfs() {
    queue<PII> q;  // 创建一个队列用于存储当前可以探索的位置
    q.push({a, b});  // 将起点位置加入队列，表示从起点开始搜索
    memset(d, -1, sizeof(d));  // 初始化 d 数组为 -1，表示所有位置都未访问过

    d[a][b] = 0;  // 起点到自己的距离为 0
    // 定义四个方向的移动向量，上、右、下、左
    int dx[4] = {-1, 0, 1, 0};  
    int dy[4] = {0, 1, 0, -1};  

    // 当队列不为空时，继续进行广度优先搜索
    while (!q.empty()) {
        PII t = q.front();  // 取出队首元素（当前的位置）
        q.pop();  // 弹出队首元素

        // 如果当前的位置就是终点，则返回从起点到终点的最短路径长度
        if (t.first == c && t.second == h) {
            return d[t.first][t.second];
        }

        // 遍历四个方向，尝试从当前位置移动到四个相邻的格子
        for (int i = 0; i < 4; ++i) {
            int x = t.first + dx[i];  // 计算移动后的新行位置
            int y = t.second + dy[i];  // 计算移动后的新列位置

            // 判断移动后的新位置是否在迷宫边界内，是否是道路，且是否未访问过
            if (x >= 1 && x <= n && y >= 1 && y <= m && g[x][y] == 1 && d[x][y] == -1) {
                d[x][y] = d[t.first][t.second] + 1;  // 更新新位置的步数（等于当前位置的步数加 1）
                q.push({x, y});  // 将新位置加入队列，准备进一步探索
            }
        }
    }

    // 如果搜索结束后仍未找到终点，返回 -1 表示无法到达
    return -1;
}

int main() {
    cin >> n >> m;  // 输入迷宫的行数和列数

    // 输入迷宫地图，1 表示道路，0 表示障碍物
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            cin >> g[i][j];
        }
    }

    // 输入起点和终点的坐标
    cin >> a >> b >> c >> h;

    // 输出从起点到终点的最短路径长度
    cout << bfs() << endl;

    return 0;
}
----------------------------------------------------------------------------------------
输入：
5 5 
1 0 1 1 0
1 1 0 1 1 
0 1 0 1 1
1 1 1 1 1
1 0 0 0 1
1 1 5 5 
输出：
8