什么？你还不会树链剖分？

最新推荐文章于 2024-07-25 13:44:24 发布

狂暴刷题组长

最新推荐文章于 2024-07-25 13:44:24 发布

阅读量100

点赞数 4

分类专栏： # 算法学习笔记文章标签：算法 c++ 学习数据结构

本文链接：https://blog.csdn.net/GROZAX/article/details/130139565

版权

算法学习笔记专栏收录该内容

9 篇文章 1 订阅

订阅专栏

先来看一条题目：（洛谷P3384）

我们有很多种方法来维护一个数组，但却很少去维护一棵树，就算是splay也是用平衡树来维护一个数组的，为什么？因为查询树上的一段路径或者修改确实很麻烦，首先需要用LCA找到这一条路径，再将每个数修改，每次操作的复杂度为 $O(nlogn)$ ，如果操作数一多，很明显就不行了。

那么如何维护一棵树的内容呢？树链剖分就提供了一种把树划分成最多logN个序列的方法，使的每次修改或查询一个区间的复杂度在 $O(log^2n)$ 内。首先来介绍几个概念：

重孩子：某个节点中子树最大的孩子节点

轻孩子：除了重儿子以外的其他孩子节点

注：如果有多个孩子子树一样都是最大，那么任取一个作为重孩子，其余作为轻孩子即可

重边：重孩子与其父亲的连边被称为重边

轻边：轻………………………………轻边

重链：相连的重边形成一条重链

如果我们把轻孩子叶节点也看作是一条重链，那么一棵树的节点就可以划分成若干重链，如下图：

定理：任意一条树上路径都可以划分成不超过logN条重链

证明：为了使划分的重链数量尽可能多，我们要尽量减小重链的长度，也就是不能让重边链接太多，那么不难想到树越平衡，重边的分布约分散，也就越能构造出更多重链，当树完全平衡时，我们从根节点向下走，去掉与父节点连接的重点，剩下的可以构造出新的重链，每次向下走，子树的个数应该/2，那么走到最后重链个数应该不超过logN，证明完毕。

然后我们考虑如何用一个一维数组依次存下这些重链。可以重新给节点编号，让dfs按照优先搜索重孩子的规则往下搜，每个节点的新编号就是dfs的搜索顺序，那么最后形成的这个数组一定可以满足：

1、同一条重链的所有节点均在一段连续的区间内

2、一棵子树的所有节点也分布在一段连续的区间内

比如刚才那棵树：

那么对于拆分后的数组，修改和查询子树很容易，直接找一段连续的区间即可，修改和查询一条路径也并不难，因为相同重链的点一定是连续的，所以我们每次在一条重链时，就加上一段连续的区间，最后把这些区间的结果拼起来就是最终的结果。

实现树链剖分也不难，观察重链的规律，不难发现

1、每条重链深度最浅的点一定是轻点

2、每个节点只会在一条重链里

3、按照dfs的搜索顺序，从某个轻节点向下走到底就是一条重链

那么只需要用到两次dfs，第一次记录下每个节点的父亲、子树大小，重孩子和深度，第二次就可以求出某个点所在的重链和重链大小。

各数组定义：

w[ i ]: 点 i 原来的权值

nw[ i ]: 在新数组中的 i 的权值

id[ i ]: 点 i 在新数组的下标

sz[ i ]: 重链 i 的大小

top[ i ]: 点 i 所在重链的顶点

dep[ i ]：点 i 的深度

fa[ i ]：点 i 的父节点

son[ i ]：点 i 的重孩子

void dfs1(int u, int father, int depth) {
    fa[u] = father; dep[u] = depth; sz[u] = 1;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (j == father) continue;
        dfs1(j, u, depth + 1);
        sz[u] += sz[j];
        if (sz[son[u]] < sz[j]) son[u] = j;
    }
}

void dfs2(int u, int k) {
    id[u] = ++cnt; nw[cnt] = w[u]; top[u] = k;
    if (!son[u]) return;
    dfs2(son[u], k);
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (j == fa[u] || j == son[u]) continue;
        dfs2(j, j);
    }
}

回到题目，在我们将题目给的一棵树转化成一个数组后，几个操作本质上就转化成了区间查询和区间修改的问题，对于这样的问题可以用树状数组、线段树，也可以用splay，这里给出线段树的方法。线段树的建树与维护不再多言，重点说一下修改和查询路径函数：

void modify_link(int u, int v, int k) {
    while (top[u] != top[v]) { //如果u和v还不在同一链上
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        modify(1, id[top[u]], id[u], k); //现将当前链修改
        u = fa[top[u]]; //将u跳到下一条链
    }
    if (dep[u] < dep[v]) swap(u, v); //此时u，v在同一条链上
    modify(1, id[v], id[u], k);  //直接按顺序修改
}
//询问操作和修改基本一致
LL query_link(int u, int v) {
    LL res = 0;
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        res += query(1, id[top[u]], id[u]);
        u = fa[top[u]];
    }
    if (dep[u] < dep[v]) swap(u, v);
    res += query(1, id[v], id[u]);
    return res;
}

由于同一颗子树序列下标连续，那么修改或查询的左右端点就是[id[u], id[u] + sz[u] - 1]；

最后附上完整代码：

#include <iostream>
#include <cstring>
#include <cstdio>

using namespace std;

typedef long long LL;
const int N = 2e5 + 10, M = N * 2;

struct node{
    int l, r;
    LL add, sum;
}tr[N * 4];
int n, m, R, mod;
int e[M], ne[M], h[N], w[N], idx;
int sz[N], dep[N], fa[N], son[N];
int id[N], nw[N], top[N], cnt;

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

void dfs1(int u, int father, int depth) {
    fa[u] = father; dep[u] = depth; sz[u] = 1;
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (j == father) continue;
        dfs1(j, u, depth + 1);
        sz[u] += sz[j];
        if (sz[son[u]] < sz[j]) son[u] = j;
    }
}

void dfs2(int u, int k) {
    id[u] = ++cnt; nw[cnt] = w[u]; top[u] = k;
    if (!son[u]) return;
    dfs2(son[u], k);
    for (int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if (j == fa[u] || j == son[u]) continue;
        dfs2(j, j);
    }
}

void pushup(int u) {
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

void pushdown(int u) {
    auto& root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
    if (root.add) {
        left.add += root.add; left.sum += root.add * (left.r - left.l + 1);
        right.add += root.add; right.sum += root.add * (right.r - right.l + 1);
        root.add = 0;
    }
}

void build(int u, int l, int r) {
    tr[u] = {l, r, 0, nw[l]};
    if (l == r) return;
    int mid = l + r >> 1;
    build(u << 1, l, mid); build(u << 1 | 1, mid + 1, r);
    pushup(u);
}

void modify(int u, int l, int r, int k) {
    if (tr[u].l >= l && tr[u].r <= r) {
        tr[u].add += k;
        tr[u].sum += k * (tr[u].r - tr[u].l + 1);
        return;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid) modify(u << 1, l, r, k);
    if (r > mid) modify(u << 1 | 1, l, r, k);
    pushup(u);

}

LL query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].sum;
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    LL res = 0;
    if (l <= mid) res = query(u << 1, l, r);
    if (r > mid) res += query(u << 1 | 1, l, r);
    return res;
}

void modify_link(int u, int v, int k) {
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        modify(1, id[top[u]], id[u], k);
        u = fa[top[u]];
    }
    if (dep[u] < dep[v]) swap(u, v);
    modify(1, id[v], id[u], k);
}

void modify_tree(int u, int k) {
    modify(1, id[u], id[u] + sz[u] - 1, k);
}

LL query_link(int u, int v) {
    LL res = 0;
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        res += query(1, id[top[u]], id[u]);
        u = fa[top[u]];
    }
    if (dep[u] < dep[v]) swap(u, v);
    res += query(1, id[v], id[u]);
    return res;
}

LL query_tree(int u) {
    return query(1, id[u], id[u] + sz[u] - 1);
}

int main() {
    memset(h, -1, sizeof h);
    scanf("%d%d%d%d", &n, &m, &R, &mod);
    for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
    for (int i = 0; i < n - 1; i++) {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b); add(b, a);
    }
    dfs1(R, -1, 1);
    dfs2(R, R);
    build(1, 1, n);

    while (m--) {
        int op, u, v, k;
        scanf("%d%d", &op, &u);
        if (op == 1) {
            scanf("%d%d", &v, &k);
            modify_link(u, v, k);
        }
        else if (op == 3) {
            scanf("%d", &k);
            modify_tree(u, k);
        }
        else if (op == 2) {
            scanf("%d", &v);
            printf("%lld\n", query_link(u, v) % mod);
        }
        else printf("%lld\n", query_tree(u)% mod);
    }
    return 0;
}

本人能力有限，文章难免会有纰漏，还望各位多多指正。如果这篇文章对你有帮助，请点一下赞和关注，这对我来说是最大的支持！谢谢！