BFS（宽度优先搜索）

前言

BFS 全称是 Breadth First Search ，中文名是宽度优先搜索，也叫广度优先搜索。

是图上最基础、最重要的搜索算法之一。

所谓宽度优先。就是每次都尝试访问同一层的节点。 如果同一层都访问完了，再访问下一层。

这样做的结果是，BFS 算法找到的路径是从起点开始的最短合法路径。换言之，这条路所包含的边数最小。

在 BFS 结束时，每个节点都是通过从起点到该点的最短路径访问的。

算法过程可以看做是图上火苗传播的过程：最开始只有起点着火了，在每一时刻，有火的节点都向它相邻的所有节点传播火苗。

实现

伪代码：

bfs(s) {
    q = new queue()
    q.push(s), visited[s] = true
    while (!q.empty()) {
        u = q.pop()
        for each edge(u, v) {
            if (!visited[v]) {
                q.push(v)
                visited[v] = true
            }
        }
    }
}

C++：

void bfs(int u) {
    while (!Q.empty()) Q.pop();
    Q.push(u);
    vis[u] = 1;
    d[u] = 0;
    p[u] = -1;
    while (!Q.empty()) {
        u = Q.front();
        Q.pop();
        for (int i = head[u]; i; i = e[i].x) {
            if (!vis[e[i].t]) {
                Q.push(e[i].t);
                vis[e[i].t] = 1;
                d[e[i].t] = d[u] + 1;
                p[e[i].t] = u;
            }
        }
    }
}
void restore(int x) {
    vector<int> res;
    for (int v = x; v != -1; v = p[v]) {
        res.push_back(v);
    }
    std::reverse(res.begin(), res.end());
    for (int i = 0; i < res.size(); ++i) printf("%d", res[i]);
    puts("");
}

具体来说，我们用一个队列 Q 来记录要处理的节点，然后开一个 $vis[]$
布尔数组来标记某个节点是否已经访问过了。

开始的时候，我们把起点 s 以外的节点的 vis 值设为 0，意思是没有访问过。然后把起点 s 放入队列 Q 中。

之后，我们每次从队列 Q 中取出队首的点 u，把 u 相邻的所有点 v 标记为已经访问过了并放入队列 Q。

直到某一时刻，队列 Q 为空，这时 BFS 结束。

在 BFS 的过程中，也可以记录一些额外的信息。比如上面的代码中，d 数组是用来记录某个点到起点的距离（要经过的最少边数），p 数组是记录从起点到这个点的最短路上的上一个点。

有了 d 数组，可以方便地得到起点到一个点的距离。

有了 p 数组，可以方便地还原出起点到一个点的最短路径。上面的 restore 函数就是在做这件事：restore(x) 输出的是从起点到 x 这个点所经过的点。

时间复杂度 $O(n+m)$

空间复杂度 $O(n)$ （vis 数组和队列）