【算法学习笔记】18：树与图的DFS与BFS

1 邻接表

树和图的DFS和BFS，可以将树也看成图来存储，存储图的一个常用的存储结构就是邻接表。对于有向图而言，只存这个方向的边，对于无向图而言，存两个方向的边。

在邻接表的实现中，用数组h来记录每个节点向外的边的链表头指针，初始时都是空（即-1）。用idx来表示链表节点的分配位置。数组e表示节点的值，即是目标节点的编号。数组ne表示节点的$next$指针，也就是链表节点的下一节点被分配的下标。

注意，当用邻接表去存无向图（或者树）的时候，因为$a\to b$和$b\to a$的边都要存，所以放置链表节点信息的e数组和ne数组至少要开到边总数目的两倍大。

// 邻接表：结点数组、链表里的值（存目标节点）、链表结点next、链表节点分配点
int h[N], e[M], ne[M], idx;

// 在a和b之间添加有向边
void add_edge(int a, int b) {
	// 创建新链表节点
    e[idx] = b;
    // 节点的next指向a的链表第一个元素（头插）
    ne[idx] = h[a];
    // a的链表头指针指向新的这个idx位置的节点
    // idx作为分配位置分配完新的链表节点要加1
    h[a] = idx ++ ;
}

2 例题：树的重心

这题是树上DFS问题。

可以想到对于树上的每个节点，把它拆了之后所有的联通块就是：每个子树是一个（每个子节点为根的子树），然后再除了自己，剩下的是另一个（父节点所在的）：

所以只需要在DFS计算每个子树的节点数目的时候来计算一下各个联通块里节点数是多少，然后求一个$max$就是把当前这个点拆掉之后的所有连通块点数最大值，然后再和全局的答案求一个$min$，最后全局的答案就存了所有这个信息的最小值，也就是题目所求。

由于树也是一个无向图，这里用邻接表来存储这棵树，注意每条边要来回存两次。另外，单从一个无向图其实没法看出谁是树根，但是实际上谁是树根都无所谓，这里直接把$1$号点当成树根就行了。

由于树中$N$个点边就是$N-1$个，是同一个规模的，所以按照邻接表存无向图的规则，只要把e和ne开到无向边数的两倍大就行了，所以代码里开到$2N$的规模。

既然用邻接表存了，要注意如何判断和一个节点$u$相邻的另一个节点$j$到底是$u$的孩子还是父亲，这里在DFS的时候记录一个st数组表示一个节点有没有遍历过。由于从根节点开始遍历，所以父节点一定先于子节点访问，所以只有判断st记录j有没有访问过就可以了。一定有且只有一个访问过的j，它是u的父节点。

#include <iostream>
#include <cstring>

using namespace std;

// 图的节点数目规模N，邻接表链表节点数目M
const int N = 1e5 + 10, M = 2e5 + 10;

// 节点数组
int n;

// 邻接表
int h[N], e[M], ne[M], idx;

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

// 记录每个节点有没有dfs算过
// 对于u的所有相连的j，如果j算过了说明是u的父亲
bool st[N];

// 整体答案："剩余各个连通块中点数的最大值"的最小值
// 实际上可以初始化为N，因为最大就是一个大连通块，点数是N
int ans = N;

// 返回u为树根的子树的节点数
int dfs(int u) {
    // 记录u被dfs过了
    st[u] = true;
    // 剩余连通块中点数最大值
    int max_val = 0;
    // u为根的子树节点数
    int res = 1;
    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i];
        // 跳过父节点
        if (st[j]) continue;
        // 子节点的连通块大小
        int t = dfs(j);
        res += t;
        max_val = max(max_val, t);
    }
    // 还要和上面的连通块比较一下
    max_val = max(max_val, n - res);
    // 计算整体答案
    ans = min(ans, max_val);
    return res;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    // 清空邻接表
    memset(h, -1, sizeof h);
    // 读取n-1条双向边
    cin >> n;
    for (int i = 0; i < n - 1; i ++ ) {
        int a, b;
        cin >> a >> b;
        add_edge(a, b);
        add_edge(b, a);
    }
    // 随便选一个位置拎起来当树根就行了
    dfs(1);
    cout << ans << endl;
    return 0;
}

3 例题：图中点的层次

这题是图的BFS的模板题了，只要维护一下从$1$到每个点的距离就可以了。

#include <iostream>
#include <queue>
#include <cstring>

using namespace std;

int n, m;

const int N = 1e5 + 10;

int h[N], e[N], ne[N], idx;

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

int d[N];

int bfs() {
    memset(d, -1, sizeof d);
    d[1] = 0;
    queue<int> q;
    q.push(1);
    while (q.size()) {
        int t = q.front();
        q.pop();
        for (int i = h[t]; i != -1; i = ne[i]) {
            int j = e[i];
            if (d[j] == -1) {
                d[j] = d[t] + 1;
                q.push(j);
            }
        }
    }
    return d[n];
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for (int i = 0; i < m; i ++ ) {
        int a, b;
        cin >> a >> b;
        add_edge(a, b);
    }
    cout << bfs() << endl;
    return 0;
}