【树论】树的重心

原创于 2025-08-26 23:30:00 发布 · 795 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#图论 #算法 #c++

ACM 专栏收录该内容

42 篇文章

订阅专栏

一、什么是树的重心？

1.1 定义

对于一棵无根树，树的重心是指这样一个节点：当以该节点为根时，其所有子树中最大的子树节点数量最小。

换句话说，树的重心是使得删除该节点后，所得到的各个连通分量中最大连通分量的节点数最小的节点。

注意：一棵树可能有一个或两个重心。如果有两个重心，它们必定是相邻的。

二、树的重心的性质

理解这些性质有助于深入掌握重心的本质：

2.1 基本性质

最小化最大子树大小：
重心使得以它为根时，最大的子树尽可能小。
最多两个重心：
一棵树最多有两个重心。如果有两个，它们之间的边是树的“平衡点”。
两个重心相邻：
如果有两个重心，它们一定是相邻的。删除连接它们的边后，得到的两个子树节点数相等（或相差1）。
重心位于树的“中心”：
从直径的角度看，重心不一定在直径上，但通常靠近中心区域。
删除重心后，每个连通分量的大小 ≤ ⌊n/2⌋：
这是判断一个点是否为重心的关键性质。

三、树的重心的应用

树的分治（Centroid Decomposition）：
用于高效处理树上的路径问题，如：求距离为 k 的点对数量、路径统计等。
网络中心选址：
在通信网络中，选择一个节点作为中心，使得最远节点距离最小（虽然更常用的是树的中心，但重心也有类似思想）。
优化树形 DP：
某些树形动态规划可以通过重心分解来优化复杂度。
避免退化树结构：
在构建平衡树结构时，选择重心作为根可以保证递归深度为 O(log n)。

四、如何求树的重心？

4.1 核心思想

我们通过一次 DFS（深度优先搜索）遍历整棵树，对每个节点 u，计算以它为根时，其各个子树的大小，并记录最大子树的大小。同时，考虑父节点方向的“上方子树”（即整棵树去掉以 u 为根的子树后的部分）。

对于节点 u，其最大连通分量大小为：

max( max{ size[v] | v 是 u 的子节点 },
      n - size[u] )

其中 size[u] 表示以 u 为根的子树的节点数。

我们要找的就是使这个值最小的节点。

4.2 算法步骤

建图（邻接表表示无向树）。
任选一个节点（如节点 1）作为根，进行 DFS。
在 DFS 中计算每个节点的子树大小 size[u]。
对每个节点 u，计算删除 u 后最大连通分量的大小：
- 子树中的最大 size[v]
- 父节点方向的连通分量大小：n - size[u]
记录使最大连通分量最小的节点（即重心）。

五、C++ 实现

下面是一个完整的 C++ 程序，包含输入、建图、DFS 计算重心、输出结果。

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

const int MAXN = 100005; // 最大节点数

vector<int> graph[MAXN]; // 邻接表存图
int size[MAXN];          // size[u]: 以 u 为根的子树的节点数
int maxSubtree[MAXN];    // maxSubtree[u]: 删除 u 后最大连通分量的大小
int n;                   // 节点数

/**
 * DFS 计算子树大小和最大子树
 * @param u 当前节点
 * @param parent 父节点
 */
void dfs(int u, int parent) {
    size[u] = 1; // 自身
    maxSubtree[u] = 0; // 初始化最大子树为 0

    for (int v : graph[u]) {
        if (v == parent) continue; // 跳过父节点

        dfs(v, u); // 递归处理子树

        size[u] += size[v]; // 累加子树大小
        maxSubtree[u] = max(maxSubtree[u], size[v]); // 更新子树中的最大值
    }

    // 考虑父节点方向的连通分量（即 n - size[u]）
    maxSubtree[u] = max(maxSubtree[u], n - size[u]);
}

/**
 * 寻找树的重心
 * @return 重心节点的列表
 */
vector<int> findCentroids() {
    dfs(1, -1); // 从节点 1 开始 DFS

    // 找到所有使 maxSubtree[u] 最小的节点
    int minMaxSubtree = *min_element(maxSubtree + 1, maxSubtree + n + 1);
    vector<int> centroids;

    for (int i = 1; i <= n; ++i) {
        if (maxSubtree[i] == minMaxSubtree) {
            centroids.push_back(i);
        }
    }

    return centroids;
}

int main() {
    // 输入节点数
    cout << "请输入树的节点数 n: ";
    cin >> n;

    // 输入 n-1 条边
    cout << "请输入 " << n-1 << " 条边 (每条边两个节点，用空格分隔):" << endl;
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        graph[u].push_back(v);
        graph[v].push_back(u);
    }

    // 查找重心
    vector<int> centroids = findCentroids();

    // 输出结果
    cout << "\n树的重心是: ";
    for (int centroid : centroids) {
        cout << centroid << " ";
    }
    cout << endl;

    cout << "重心对应的最小最大连通分量大小为: " 
         << maxSubtree[centroids[0]] << endl;

    // 验证性质：删除重心后，每个连通分量 <= n/2
    cout << "验证：删除重心后，最大连通分量大小 <= floor(n/2) = " 
         << n/2 << endl;

    return 0;
}

六、代码详解

6.1 数据结构

graph[MAXN]：邻接表存储无向树。
size[u]：DFS 过程中计算的子树大小。
maxSubtree[u]：删除节点 u 后，最大连通分量的大小。

6.2 DFS 函数

递归计算每个节点的子树大小。
对每个子节点 v，更新 maxSubtree[u] = max(maxSubtree[u], size[v])。
最后考虑父方向：maxSubtree[u] = max(maxSubtree[u], n - size[u])。

6.3 重心判断

找出所有 maxSubtree[u] 最小的节点。
这些节点就是树的重心。

七、复杂度分析

时间复杂度：O(n)
- 一次 DFS 遍历所有节点和边。
- 最后遍历一次找最小值。
空间复杂度：O(n)
- 存储图、子树大小、最大子树数组等。

八、举例说明

示例 1：链状树

1 -- 2 -- 3 -- 4 -- 5

n = 5
重心是节点 3
删除 3 后，最大连通分量大小为 2 ≤ ⌊5/2⌋ = 2

示例 2：星形树

    1
   /|\
  2 3 4

n = 4
重心是节点 1
删除 1 后，最大连通分量大小为 1 ≤ ⌊4/2⌋ = 2

示例 3：两个重心的情况

1 -- 2 -- 3 -- 4

n = 4
重心是节点 2 和 3
删除 2：连通分量大小为 max(1, 3) = 3？不对！

更正：对于链 1-2-3-4：

节点 2：子树大小 max(1, 2) = 2；父方向：4-3=1 → max=2
节点 3：子树大小 max(1, 2) = 2；父方向：4-3=1 → max=2
所以 2 和 3 都是重心，且相邻。

九、常见误区

误认为重心是度最大的点：
不对！星形树中中心是重心，但链状树中重心是中间点，度为 2。
误认为重心一定唯一：
一棵树可以有两个重心。
忘记考虑父方向的连通分量：
这是初学者常犯的错误。必须考虑 n - size[u]。

十、进阶：树的重心与树的中心区别

特性	树的重心	树的中心
定义	最大子树最小	最远距离最小（偏心率最小）
依据	节点数量	路径长度
数量	1 或 2	1 或 2
求法	DFS 计算子树大小	两次 BFS/DFS 求直径中点