BFS

BFS 与 DFS 的时间复杂度相同，都是 $O(n+m)$，其中 n 表示图的节点数，m 表示图的边数。

当树或者图的所有边的权重都是 1 时，才可以使用 BFS 求最短距离，否则应该使用 DFS 考虑所有情况。

当权重不是 1 的时候，应该使用 Dijkstra 等算法来求最短距离。

BFS 原理

队列 —> 先进先出 —> BFS

栈 —> 后进先出 —> DFS

所有的 BFS、DFS 都可以对应一颗树。

bfs 遍历顺序：

bfs 实现遍历主要是依靠 队列 来做。每次取出队头元素，然后再将队头元素的所有子节点加入队尾，一开始将根节点放入空队列中，这样就实现 bfs 遍历了。

通过上图，你会惊奇地发现：队头元素出队的顺序 与 元素加入队列的顺序 竟然一样！

BFS 代码

实现 bfs 需要两种数组： 判重数组（定义为布尔数组 st）、队列（用数组实现）。

绝大部分 bfs 都是在节点入队时判重，但是特殊的算法（比如 Dijkstra）会在出队时判重。

为什么需要判重数组？

没有判重数组的话，bfs 搜索树可能会出现 环，这样就会导致死循环的发生。

队列在 BFS 中的操作

对于 队列操作，bfs 框架为：

queue <-- 初始状态
while (queue 非空) {
    
	t <-- 队头元素
   for (拓展 t) {
    
       ver <-- 新节点
       if (!st[ver]) {
    
           在队尾插入 ver
       }
   }
}

BFS 解决的问题

**迷宫问题是 BFS 最重要的一个问题。我们常常用 BFS 搜索从起点到终点的最短路步长，最短步长就是 BFS 递归的层数。**这是因为 bfs 搜索树的每一层的节点都代表了一种选择，它是按照距离来遍历点的，一开始遍历距离为 1 的点，再从距离为 1 的点开始，遍历离起点 距离 为 2 的点，以此类推…… 因此从起点到终点的最小层数就是短步长。

比如这个迷宫的 bfs 搜索树（S 表示起点，E 表示终点）

树与图的 BFS

错误

利用 BFS 求从节点 1 到节点 n 的最短距离。

错误代码：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <queue>

using namespace std;

const int N = 100010, M = 2 * N;
int n, m;
int h[N], e[M], ne[M], idx;
bool st[N];
int d[N]; // d[i]存储从1号点到i号店的最短路径，可以将 d 数组初始化为 -1，表示当前节点还没有被遍历过。
//! 注意，对于树来说，你可以使用布尔数组st[i]来表示当前节点是否已经被遍历过。这是因为在树结构中，i号节点只可能被它的父节点遍历
//! 注意，对于图来说，你不能用一个布尔数组st[i]来表示当前节点是否已经被遍历过。这是因为在图结构中，可能有多个节点指向i号节点

void init() {
    
    memset(h, -1, sizeof h);
    memset(d, -1, sizeof d);
}

void add(int a, int b) {
    
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}

void bfs() {
    
    queue<int> q;
    q.push(1);
    // st[1] = true;

    while(q.size()) {
    
        int now = q.front();
        q.pop();

        if (!st[now]) {
    
            st[now] = true;
            for (int i = h[now]; ~i; i = ne[i]) {
    
                int j = e[i];
                
                q.push(j);
                d[j] = d[now] + 1;
                if (j == n) return;
            }
        }
    }
}

int main()
{
    
    init();
    scanf("%d%d", &n, &m);

    int a, b;
    for (int i = 1; i <= m; ++i) {
    
        scanf("%d%d", &a, &b);
        add(a, b);
    }

    bfs();
    printf("%d\n", d[n]);
}

正确代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <queue>

using namespace std;

const int N = 100010, M = 2 * N;
int n, m;
int h[N], e[M], ne[M], idx;
bool st[N];
int d[N]; // d[i]存储从1号点到i号店的最短路径，可以将 d 数组初始化为 -1，表示当前节点还没有被遍历过。
//! 注意，对于树来说，你可以使用布尔数组st[i]来表示当前节点是否已经被遍历过。这是因为在树结构中，i号节点只可能被它的父节点遍历
//! 注意，对于图来说，你不能用一个布尔数组st[i]来表示当前节点是否已经被遍历过。这是因为在图结构中，可能有多个节点指向i号节点

void init() {
    
    memset(h, -1, sizeof h);
    memset(d, -1, sizeof d);
}

void add(int a, int b) {
    
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}

void bfs() {
    
    queue<int> q;
    q.push(1);
    // st[1] = true;
    d[1] = 0; //* 这一步初始化容易忘记

    while(q.size()) {
    
        int now = q.front();
        q.pop();


        for (int i = h[now]; ~i; i = ne[i]) {
    
            int j = e[i];
            
            if (d[j] == -1) {
    
                q.push(j);
                d[j] = d[now] + 1;
                if (j == n) return;
            }

        }
    }
}

int main()
{
    
    init();
    scanf("%d%d", &n, &m);

    int a, b;
    for (int i = 1; i <= m; ++i) {
    
        scanf("%d%d", &a, &b);
        add(a, b);
    }

    bfs();
    printf("%d\n", d[n]);
}

AcWing