图的广度优先搜索（算法）

步骤：

1. 新建一个队列，放入起始点

2. 弹出第一个节点，对其进行处理（同时标记为已访问）

3. 遍历其所有相连的节点，把未访问的放到队列后边

4. 重复23直到队列为空

注意：

1. 在图中，必须记录节点是否被访问，否则可能会陷入循环

代码：

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

// 图的结点
struct Node {
    int value;
    vector<Node*> neighbors;

    Node(int val) : value(val) {}
};

// 广度优先搜索函数
void BFS(Node* start) {
    if (!start)
        return;

    queue<Node*> q;
    vector<bool> visited;

    // 初始化队列和访问标志数组
    q.push(start);
    visited.assign(1000, false); // 这里假设结点的值不超过1000

    while (!q.empty()) {
        Node* current = q.front();
        q.pop();

        // 如果结点已被访问，则跳过
        if (visited[current->value])
            continue;

        // 访问当前结点
        cout << current->value << " ";
        visited[current->value] = true;

        // 将未访问的邻居结点加入队列
        for (Node* neighbor : current->neighbors) {
            if (!visited[neighbor->value])
                q.push(neighbor);
        }
    }
}

int main() {
    // 构建图
    Node* node1 = new Node(1);
    Node* node2 = new Node(2);
    Node* node3 = new Node(3);
    Node* node4 = new Node(4);
    Node* node5 = new Node(5);

    node1->neighbors.push_back(node2);
    node1->neighbors.push_back(node3);
    node2->neighbors.push_back(node4);
    node3->neighbors.push_back(node4);
    node3->neighbors.push_back(node5);
    node4->neighbors.push_back(node5);

    // 从结点1开始进行广度优先搜索
    cout << "BFS traversal: ";
    BFS(node1);

    // 释放内存
    delete node1;
    delete node2;
    delete node3;
    delete node4;
    delete node5;

    return 0;
}

 最短路径问题：

1. 使用queue，包含位置坐标和距离起点距离

queue<tuple<int, int, int>> q;
//使用d+1来确定位置
q.emplace(nx, ny, d + 1);

2. 记得把看过的记录上，避免重复（有时可与题目结合，简化记录方法）

 // 新坐标为空格子且不为出口，修改为墙并加入队列
            maze[nx][ny] = '+';
            q.emplace(nx, ny, d + 1);

3. 使用数组来遍历上下左右

        // 上下左右四个相邻坐标对应的行列变化量
        vector<int> dx = {1, 0, -1, 0};
        vector<int> dy = {0, 1, 0, -1};

        // 遍历四个方向相邻坐标
        for (int k = 0; k < 4; ++k){
             int nx = cx + dx[k];
             int ny = cy + dy[k];
         }

例题 

 代码：

class Solution {
public:
    int nearestExit(vector<vector<char>>& maze, vector<int>& entrance) {
        int m = maze.size();
        int n = maze[0].size();
        // 上下左右四个相邻坐标对应的行列变化量
        vector<int> dx = {1, 0, -1, 0};
        vector<int> dy = {0, 1, 0, -1};
        queue<tuple<int, int, int>> q;
        // 入口加入队列并修改为墙
        q.emplace(entrance[0], entrance[1], 0);
        maze[entrance[0]][entrance[1]] = '+';
        while (!q.empty()){
            auto [cx, cy, d] = q.front();
            q.pop();
            // 遍历四个方向相邻坐标
            for (int k = 0; k < 4; ++k){
                int nx = cx + dx[k];
                int ny = cy + dy[k];
                // 新坐标合法且不为墙
                if (nx >= 0 && nx < m && ny >= 0 && ny < n && maze[nx][ny] == '.'){
                    if (nx == 0 || nx == m - 1 || ny == 0 || ny == n - 1){
                        // 新坐标为出口，返回距离作为答案
                        return d + 1;
                    }
                    // 新坐标为空格子且不为出口，修改为墙并加入队列
                    maze[nx][ny] = '+';
                    q.emplace(nx, ny, d + 1);
                }
            }
        }
        // 不存在到出口的路径，返回 -1
        return -1;
    }
};