【树论】树链剖分

最新推荐文章于 2025-12-02 15:32:05 发布
原创 最新推荐文章于 2025-12-02 15:32:05 发布 · 845 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #c++ #图论

一、为什么需要树链剖分？

1.1 问题背景

在树上，我们经常需要处理以下类型的操作：

  • 将节点 u 到 v 的路径上的所有点权 + x
  • 查询节点 u 到 v 的路径上所有点权的最大值
  • 将以 u 为根的子树所有节点权值 + x
  • 查询以 u 为根的子树的所有节点权值和

这些问题如果用 LCA + 暴力遍历路径，单次操作复杂度为 O(n)，效率极低。

1.2 解决思路

树链剖分的核心思想是：

把树“拉直”成一条线，然后用线段树维护这条线，从而将树上路径操作转化为区间操作。

但直接“拉直”会丢失结构信息。树链剖分通过一种有规则的 DFS 序，保证了：任意两点间的路径，最多由 O(log n) 条连续的链组成。

二、核心概念与定义

2.1 重儿子（Heavy Child）

  • 对于一个非叶子节点 u，其子树大小最大的子节点称为 u 的重儿子。
  • 如果有多个子树大小相同，任选一个即可。

2.2 轻儿子（Light Child）

  • 除了重儿子之外的所有子节点都是轻儿子。

2.3 重边（Heavy Edge）

  • 父节点与其重儿子之间的边。

2.4 轻边（Light Edge）

  • 父节点与其轻儿子之间的边。

2.5 重链（Heavy Path）

  • 由重边连接形成的极大路径。
  • 每条重链的起点是轻儿子或根节点，终点是叶子节点或重儿子的轻儿子。

✅ 关键性质：从任意节点到根的路径上，最多经过 O(log n) 条轻边，因此最多经过 O(log n) 条重链。

三、树链剖分的两个 DFS

3.1 第一次 DFS：计算子树大小、深度、父节点、重儿子

void dfs1(int u, int parent, int depth) {
    dep[u] = depth;
    fa[u] = parent;
    sz[u] = 1;  // 子树大小
    hson[u] = 0; // 重儿子初始化为 0

    for (int v : tree[u]) {
        if (v == parent) continue;
        dfs1(v, u, depth + 1);
        sz[u] += sz[v];
        if (sz[v] > sz[hson[u]]) {
            hson[u] = v; // 更新重儿子
        }
    }
}

3.2 第二次 DFS：生成 DFS 序、分配链顶、构建线性序列

int dfn = 0; // DFS 序计数器
int top[MAXN]; // top[u] 表示 u 所在重链的顶部节点
int id[MAXN];  // id[u] 表示 u 在线段树中的位置（新编号）

void dfs2(int u, int tp) {
    id[u] = ++dfn;     // 分配新编号
    top[u] = tp;       // 记录链顶

    if (hson[u]) {
        dfs2(hson[u], tp); // 重儿子继承当前链顶
    }

    for (int v : tree[u]) {
        if (v == fa[u] || v == hson[u]) continue;
        dfs2(v, v); // 轻儿子开启新链，链顶是自己
    }
}

🌟 重点：重儿子被优先访问，保证了同一条重链上的节点在线段树中是连续的。

四、树链剖分的应用：路径操作

4.1 路径查询/修改的核心思想

将 u 到 v 的路径拆成若干段重链，每段在 DFS 序上是连续的，可以用线段树区间操作。

4.2 核心函数：跳链过程

// 查询 u 到 v 路径上的最大值
int query_path(int u, int v) {
    int res = -INF;
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        // u 的链顶更深，先处理 u 所在链
        res = max(res, seg_tree.query(id[top[u]], id[u]));
        u = fa[top[u]]; // 跳到链顶的父节点（轻边）
    }
    // 现在 u 和 v 在同一条链上
    if (id[u] > id[v]) swap(u, v);
    res = max(res, seg_tree.query(id[u], id[v]));
    return res;
}

4.3 子树操作

子树操作更简单！因为子树的 DFS 序是连续的。

// 查询 u 的子树和
int query_subtree(int u) {
    return seg_tree.query(id[u], id[u] + sz[u] - 1);
}

五、C++ 实现（支持路径加、路径最大值查询）

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 1e5 + 5;
const int INF = 0x3f3f3f3f;

// ======== 树结构 ========
int n, m, r;
vector<int> tree[MAXN];
int w[MAXN]; // 初始点权

// ======== 第一次 DFS 数据 ========
int dep[MAXN], fa[MAXN], sz[MAXN], hson[MAXN];

// ======== 第二次 DFS 数据 ========
int dfn = 0;
int id[MAXN], top[MAXN];

// ======== 线段树 ========
struct Node {
    int l, r;
    int sum, max_val;
    int lazy;
} seg_tree[4 * MAXN];

void push_up(int u) {
    seg_tree[u].sum = seg_tree[u*2].sum + seg_tree[u*2+1].sum;
    seg_tree[u].max_val = max(seg_tree[u*2].max_val, seg_tree[u*2+1].max_val);
}

void push_down(int u) {
    if (seg_tree[u].lazy) {
        int lz = seg_tree[u].lazy;
        seg_tree[u*2].sum += lz * (seg_tree[u*2].r - seg_tree[u*2].l + 1);
        seg_tree[u*2+1].sum += lz * (seg_tree[u*2+1].r - seg_tree[u*2+1].l + 1);
        seg_tree[u*2].max_val += lz;
        seg_tree[u*2+1].max_val += lz;
        seg_tree[u*2].lazy += lz;
        seg_tree[u*2+1].lazy += lz;
        seg_tree[u].lazy = 0;
    }
}

void build(int u, int l, int r) {
    seg_tree[u] = {l, r, 0, -INF, 0};
    if (l == r) {
        seg_tree[u].sum = seg_tree[u].max_val = w[r]; // w 是原点权
        return;
    }
    int mid = (l + r) >> 1;
    build(u*2, l, mid);
    build(u*2+1, mid+1, r);
    push_up(u);
}

void modify(int u, int l, int r, int val) {
    if (seg_tree[u].l >= l && seg_tree[u].r <= r) {
        seg_tree[u].sum += val * (seg_tree[u].r - seg_tree[u].l + 1);
        seg_tree[u].max_val += val;
        seg_tree[u].lazy += val;
        return;
    }
    push_down(u);
    int mid = (seg_tree[u].l + seg_tree[u].r) >> 1;
    if (l <= mid) modify(u*2, l, r, val);
    if (r > mid) modify(u*2+1, l, r, val);
    push_up(u);
}

int query_sum(int u, int l, int r) {
    if (seg_tree[u].l >= l && seg_tree[u].r <= r) {
        return seg_tree[u].sum;
    }
    push_down(u);
    int mid = (seg_tree[u].l + seg_tree[u].r) >> 1;
    int res = 0;
    if (l <= mid) res += query_sum(u*2, l, r);
    if (r > mid) res += query_sum(u*2+1, l, r);
    return res;
}

int query_max(int u, int l, int r) {
    if (seg_tree[u].l >= l && seg_tree[u].r <= r) {
        return seg_tree[u].max_val;
    }
    push_down(u);
    int mid = (seg_tree[u].l + seg_tree[u].r) >> 1;
    int res = -INF;
    if (l <= mid) res = max(res, query_max(u*2, l, r));
    if (r > mid) res = max(res, query_max(u*2+1, l, r));
    return res;
}

// ======== 树链剖分 DFS ========
void dfs1(int u, int parent, int depth) {
    dep[u] = depth;
    fa[u] = parent;
    sz[u] = 1;
    hson[u] = 0;

    for (int v : tree[u]) {
        if (v == parent) continue;
        dfs1(v, u, depth + 1);
        sz[u] += sz[v];
        if (sz[v] > sz[hson[u]]) {
            hson[u] = v;
        }
    }
}

void dfs2(int u, int tp) {
    id[u] = ++dfn;
    top[u] = tp;

    if (hson[u]) {
        dfs2(hson[u], tp); // 重儿子继承链顶
    }
    for (int v : tree[u]) {
        if (v == fa[u] || v == hson[u]) continue;
        dfs2(v, v); // 轻儿子开启新链
    }
}

// ======== 路径操作接口 ========
void modify_path(int u, int v, int val) {
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        modify(1, id[top[u]], id[u], val);
        u = fa[top[u]];
    }
    if (id[u] > id[v]) swap(u, v);
    modify(1, id[u], id[v], val);
}

int query_path_max(int u, int v) {
    int res = -INF;
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        res = max(res, query_max(1, id[top[u]], id[u]));
        u = fa[top[u]];
    }
    if (id[u] > id[v]) swap(u, v);
    res = max(res, query_max(1, id[u], id[v]));
    return res;
}

// ======== 子树操作接口 ========
void modify_subtree(int u, int val) {
    modify(1, id[u], id[u] + sz[u] - 1, val);
}

int query_subtree_sum(int u) {
    return query_sum(1, id[u], id[u] + sz[u] - 1);
}

// ======== 主函数 ========
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);

    cin >> n >> m >> r;
    for (int i = 1; i <= n; ++i) {
        cin >> w[i];
    }

    for (int i = 1; i <= n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        tree[u].push_back(v);
        tree[v].push_back(u);
    }

    // 树链剖分预处理
    dfs1(r, 0, 1);
    dfs2(r, r);
    build(1, 1, n);

    // 处理 m 个操作
    while (m--) {
        int op, x, y, z;
        cin >> op;
        if (op == 1) { // 路径加
            cin >> x >> y >> z;
            modify_path(x, y, z);
        } else if (op == 2) { // 路径最大值
            cin >> x >> y;
            cout << query_path_max(x, y) << '\n';
        } else if (op == 3) { // 子树加
            cin >> x >> z;
            modify_subtree(x, z);
        } else if (op == 4) { // 子树和
            cin >> x;
            cout << query_subtree_sum(x) << '\n';
        }
    }

    return 0;
}

六、复杂度分析

操作时间复杂度说明
预处理（两次 DFS）O(n)
路径修改/查询O(log² n)每条链 O(log n)，最多 O(log n) 条链
子树修改/查询O(log n)连续区间，一次线段树操作

✅ 路径操作 O(log² n) 是树链剖分的标准复杂度。

七、核心性质与优势

  1. 路径拆分高效：任意路径最多被拆分为 O(log n) 段重链。
  2. 支持多种操作：区间加、区间最值、区间和、子树操作等。
  3. 可扩展性强：可结合懒标记、多种线段树形态。
  4. 代码模式固定：两次 DFS + 跳链循环，易于模板化。

八、注意事项

  • hson[u] 初始化为 0，表示无重儿子。
  • top[u] 在 dfs2 中赋值。
  • 线段树要支持区间修改（懒标记）。
  • 输入输出较大时使用 ios::sync_with_stdio(false)。

九、总结

树链剖分是将树的路径问题转化为线性区间问题的强大工具。其核心在于：

  1. 重轻儿子划分 → 形成重链
  2. 两次 DFS → 构建 DFS 序与链顶
  3. 跳链循环 → 将路径拆为 O(log n) 段
  4. 线段树维护 → 高效区间操作
树相关——树链剖分(轻重链剖分)
Lucas_FC_的博客
09-04 574
树链剖分(轻重链剖分)
树链剖分学习笔记
CreationAugust is 14 years old forever
02-13 1903
让我们先来看如下一个问题： 给定一棵n个节点的树，有如下两种操作： 1.修改树上一条边权值为v 2.查询树上两个节点间路径的距离 对于这个问题我们要怎么做？ 暴力？妥妥的超时。 这样我们就引入了树链剖分的算法。 在上述题目中，虽然树的边权发生了改变，但是树的形态是没有发生任何变化的。因此我们可以将树上的链取下来存入数据结构中（线段树平衡树均可）利用这些数据结构的优越性能来实现权值的修改
浅析树链剖分
Mi-Queen
05-26 373
可以看出树链剖分的作用就是将一棵树变成一个可处理的dfs序，树上操作一般由线段树来维护，看一下模板题BZOJ1036和POJ3237。
树链剖分 求 最近公共祖先（LCA)
qq_37746591的博客
03-25 1586
用树链刨分求最近公共祖先的笔记
bzoj 1036 树链剖分 解题报告
Hawo11的博客
07-13 516
树链剖分
luogu3384【模板】树链剖分
LJC00118的博客
04-15 253
题目链接 题目大意： 对一颗树进行四种操作 u 到 v 路径加 z u 到 v 路径之和 u 及 u 子树加 z u 及 u子树之和 考虑树链剖分套线段树(懒标记必须的) 每个点的重儿子是儿子当中子树大小最大的一个 进行两次dfs，分出链头及一些奇怪的东西 进行剖分时维护每个节点的size(子树大小和)值，dfs序，pre(与dfs序互为双射) 每一条链上的dfs序一定是连续的...
【树链剖分】bzoj2819 nim
FAreStorm的博客
12-04 858
题目链接：http://www.lydsy.com/JudgeOnline/problem.php?id=2819 题目大意：有一棵树，每个节点上有一堆石子，有两种操作：1.改变某个节点的nim值 2.问在u到v的路径上玩nim游戏是否有先手必胜策略
ICPC澳门20I——树链剖分优化空间复杂度，好题
hans774882968的博客
11-07 781
传送门1或者传送门2 注意，空间限制是8MB！ 这题太综合了，能独立写出来说明你能在澳门站拿金了。另外，树链剖分优化空间复杂度真的是我第一次听说~ 首先，它考察了一个博弈论的结论：若干石堆的Nim游戏，后手必胜等价于各石堆数异或和为0。所以原题等价于以下问题：保留一个子集（可空）的石堆，a属性的异或和为0，且b属性的和最大。这显然是一个01背包（大概每一个关注“树链剖分”的人都会吧~），dp表示保留出的最大b属性和，bTot - dp[idx][0]即所求。于是我们有如下代码： #include <b
「树链剖分」学习笔记
lunjiahao的博客
11-04 915
咕咕咕，终于写完了，咕了都快一个月了（），Markdown 都快卡死了。以后学了长链剖分再来补吧咕咕咕。1k1k1k行不卡才怪）
SG打表与树链剖分详解
这篇文档主要涵盖了几个重要的图论和动态规划相关的算法，包括SG打表、树链剖分、树形DP、状态压缩DP以及数论公式的一些补充内容，如素数个数和最大团问题。以下是这些知识点的详细说明： 1. SG打表 (Stable ...
树上搜索.pdf 上课讲义
08-22
在信息学竞赛中，树论问题通常涉及利用树的性质，如直径、重心、最近公共祖先、DFS序等，通过树形动态规划、树上差分、树链剖分以及分治等算法技巧来解决问题。 讲义首先定义了树：一个包含n个节点的无环联通图，...
【NOI模拟赛】纸老虎博弈（博弈论SG函数，长链剖分）
DD(XYX)的硫氰化氘博客
08-03 989
今天实在是鸽不住了
我问的是长链剖分默认的英文简写是什么
03-26
长链剖分通常出现在图论或数据结构中，尤其是在处理树形结构时，用于优化路径查询或分解树结构。 接下来，回忆相关的英文术语。中文术语“长链剖分”对应的英文可能是“Long Chain Decomposition”或类似表达。根据...
完全背包 vs 多重背包的优化逻辑
最新发布
布心老混子
12-02 188
做题时想到完全背包是可以转化成多重背包的，那么多重背包需要二进制优化，完全背包需要吗？
基于A*算法的雷雨绕飞路径MATLAB实现
2501_92729044的博客
11-30 257
本文提出了一种基于A算法的雷雨绕飞路径规划方法。该方法首先生成模拟雷雨天气图并进行二值化处理，识别危险区域；然后检测计划航路中需要绕飞的航段，通过A算法为每个航段生成左右绕飞候选路径；接着进行视距优化和平行路径拓展以提高安全性；最后整合各航段最优路径构建完整绕飞航路。实验结果表明，该方法能有效避开危险区域，生成安全且长度优化的绕飞路径。关键创新点包括：1) 结合雷达天气数据的精细化处理；2) 多候选路径生成与优化机制；3) 完整航路构建策略。可视化界面直观展示了各阶段路径规划效果。
2025年全国大学生统计科学与算法编程挑战赛——算法赛道（一）
qq_73044452的博客
12-01 261
摘要：本文包含三个编程问题的解决方案。1) 贪吃蛇问题：通过解析移动指令计算蛇最终所在格子的编号；2) 经济小鱼问题：计算前两局存钱、后两局花钱，最终剩余指定金币的方案数；3) 小理吃甜食问题：模拟多轮糖果挑选过程，计算小理获得的最大总糖果值。每个问题都给出了完整的C++实现代码，涉及字符串处理、数学计算和模拟算法等技术。
强化学习[page13]【chapter7】时序差分方法算法介绍
4AM_明朝百晓生
12-01 400
其次，式(7.1)中的TD算法仅能估计给定策略的状态值。尽管如此，本节介绍的TD算法非常基础，对理解本章其他算法至关重要。例如，本章介绍的所有算法都属于时序差分学习的范畴。为简洁起见，式(7.2)常被省略，但必须意识到若缺少该式，算法在数学上将不完整。TD 方法的一个特点是，它在每个时间步更新其值估计，而 MC 方法则要等到回合结束才更新。TD学习的核心思想是基于新获得的信息来修正当前对状态值的估计。因此，TD误差不仅反映两个时间步之间的差异，更重要的是反映了估计值。反映了时间步t与t+1之间的差异。
L1-062 幸运彩票（C++）
2301_81427201的博客
11-29 245
彩票的号码有 6 位数字，若一张彩票的前 3 位上的数之和等于后 3 位上的数之和，则称这张彩票是幸运的。本题就请你判断给定的彩票是不是幸运的。
基于C++实现（控制台）应用递推法完成经典型算法的应用
神仙别闹的自留地
12-02 164
目的是通过课程设计的综合训练，培养学生实际分析问题、解决问题的能力，以及编程和动手能力，最终目标是通过课程设计这种形式，帮助学生系统掌握C这门课程的主要内容，养成良好的编程习惯，更好的完成教学任务。经过这次课设，进一步加深了我对递推的理解，递推实际上是一个很难的东西，经过在这次课设中的三道递推题目，也许3道题目和很少，但是当我深深的吃透了这三道题，我便对递推有了新的见解。在程序调试的过程中，我先逐步调试每一个小问题，对于约瑟夫问题，通过添加断点，我才发现深入的找出了问题的所在。作用：求解五渔夫分鱼问题。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值