树链剖分(重链剖分)

已于 2023-07-22 23:17:01 修改
阅读量93 收藏
点赞数 1
文章标签： 深度优先 算法 c++
于 2023-07-18 12:38:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eyuhaobanga/article/details/131784701
版权

树链剖分(重链剖分)

树的统计

题意

​ 给定一棵树，每个节点都有一个点权，有以下三种操作：

  • 把节点 u u u的权值改为 t t t
  • 询问从点 u u u到点 v v v的路径上的节点的最大权值
  • 询问从点 u u u到点 v v v的路径上的节点的权值和
分析

​ 因为是在树上的相关操作，考虑树链剖分并且用线段树去维护区间的最大值和权值和，线段树需要完成的操作就是单点修改，区间查询最大值和权值和，在树链剖分中，第一个DFS需要求出每一个节点的子树大小、重儿子、父节点以及深度，第二个DFS需要求出DFS序，重儿子开头的节点，以及DFS序所对应的节点的编号

​ 在建立线段树时，线段树维护的区间的下标并不是树中节点本身的下标，而是DFS序的标号，根据DFS序，在一条树链上的节点的标号一定是连续的，这样就可以用线段树去维护一条条树链的信息，而线段树中的操作不需要改变，只需要改变访问线段树时访问的区间即可，因为在DFS2中，树链剖分不仅记录了DFS序( l [ i ] l[i] l[i])，还记录了DFS序所对应的节点的编号( c n t [ i ] cnt[i] cnt[i])，查询操作和树链剖分找LCA一样，只不过需要边找LCA边记录路径的信息

AC代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int n, q, a[30010];
vector<int> G[30010];
int hs[30010], sz[30010], fa[30010], dep[30010], top[30010], l[30010], r[30010], id[30010], tot;
struct info {
    int maxv, sum;
};
info operator +(const info &l, const info &r) {
    return info{max(l.maxv, r.maxv), l.sum + r.sum};
}
struct node {
    info val;
}seg[30010 << 2];
void update(int i) {
    seg[i].val = seg[i << 1].val + seg[i << 1 | 1].val;
}
void buildtree(int i, int l, int r) {
    if (l == r) {
        seg[i].val = {a[id[l]], a[id[l]]};
        return;
    }
    int mid = l + r >> 1;
    buildtree(i << 1, l, mid);
    buildtree(i << 1 | 1, mid + 1, r);
    update(i);
}
void modify(int i, int l, int r, int x, int k) {
    if (l == r) {
        seg[i].val = {k, k};
        return;
    }
    int mid = l + r >> 1;
    if (x <= mid) {
        modify(i << 1, l, mid, x, k);
    } else {
        modify(i << 1 | 1, mid + 1, r, x, k);
    }
    update(i);
}
info query(int i, int l, int r, int x, int y) {
    if (x == l && r == y) {
        return seg[i].val;
    }
    int mid = l + r >> 1;
    if (y <= mid) {
        return query(i << 1, l, mid, x, y);
    } else {
        if (x > mid) {
            return query(i << 1 | 1, mid + 1, r, x, y);
        } else {
            return query(i << 1, l, mid, x, mid) + query(i << 1 | 1, mid + 1, r, mid + 1, y);
        }
    }
}
void dfs1(int u, int f) {
    sz[u] = 1;
    hs[u] = -1;
    fa[u] = f;
    dep[u] = dep[f] + 1;
    for (auto v : G[u]) {
        if (v != f) {
            dfs1(v, u);
            sz[u] += sz[v];
            if (hs[u] == -1 || sz[v] > sz[hs[u]]) {
                hs[u] = v;
            }
        }
    }
}
void dfs2(int u, int f) {
    top[u] = f;
    l[u] = ++tot;
    id[tot] = u;
    if (hs[u] != -1) {
        dfs2(hs[u], f);
    }
    for (auto v : G[u]) {
        if (v != fa[u] && v != hs[u]) {
            dfs2(v, v);
        }
    }
    r[u] = tot;
}
info query(int x, int y) {
    info ans = {-0x3f3f3f3f, 0};
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]]) {
            ans = ans + query(1, 1, n, l[top[y]], l[y]);
            y = fa[top[y]];
        } else {
            ans = ans + query(1, 1, n, l[top[x]], l[x]);
            x = fa[top[x]];
        }
    }
    if (dep[x] < dep[y]) {
        ans = ans + query(1, 1, n, l[x], l[y]);
    } else {
        ans = ans + query(1, 1, n, l[y], l[x]);
    }
    return ans;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n;
    for (int i = 1; i < n; i++) {
        int x, y;
        cin >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    dfs1(1, 0);
    dfs2(1, 1);
    buildtree(1, 1, n);
    cin >> q;
    while (q--) {
        string op;
        cin >> op;
        int x, y;
        cin >> x >> y;
        if (op[0] == 'C') {
            modify(1, 1, n, l[x], y);
        } else {
            info ans = query(x, y);
            if (op[1] == 'M') {
                cout << ans.maxv << '\n';
            } else {
                cout << ans.sum << '\n';
            }
        }
    }
    return 0;
}

染色

题意

​ 给定一棵树，需要完成两种操作：

  • 将节点 a a a到节点 b b b的路径上的所有点(包括 a a a和 b b b)都染成颜色 c c c
  • 询问节点 a a a到节点 b b b的路径上的颜色段数量
分析

​ 依然是给定一棵树，需要完成对树上路径的操作，考虑树链剖分+线段树维护区间，根据题意可得，在线段树中我们需要维护的是区间中最左边节点的颜色、最右边节点的颜色以及不同颜色的段数，因为涉及到整个大区间的修改考虑使用懒标记的线段树维护区间，树链剖分部分的DFS1和DFS2操作不变，在线段树中每一次合并操作需要判断左儿子的右端点颜色和右儿子的左端点颜色是否一样。

​ 因为涉及到区间修改操作，区间修改操作和区间查询操作的步骤相似，都是在找LCA的操作中边找边修改路径信息，但区间查询操作略有不同，前面所有的查询或修改操作都不需要考虑区间在左在右的问题，但在这个题的区间查询操作中需要考虑查询区间的左右问题，因为涉及到比较左区间的右端点颜色和右区间的左端点颜色，区间的左右不能颠倒，否则计算区间颜色段数就会出错，在查询时是从深节点往浅节点跳着查询，所以应该是查询的区间+ans 而不是 ans+查询的区间(!)，并且节点 u u u和节点 v v v两条链一起往上跳需要分别计算两条路径的ans，不能用一个ans全部记录，根据上述操作可知，ansu记录的是LCA到u路径上的信息，ansv记录的是LCA到v路径上的信息，若要计算节点u到节点v路径上的颜色段数量，也就是计算ansu中颜色段数量+ansv中颜色段数量+(判断ansu和ansv的左端点是否相等)，至于为什么要判断是因为ansu和ansv记录的都是由浅到深节点路径的信息，所以在合并的时候需要把任意一个区间反过来才是由u到v路径上的信息

AC代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int n, q, w[100010];
vector<int> G[100010];
int hs[100010], fa[100010], sz[100010], dep[100010], top[100010], l[100010], r[100010], id[100010], tot;
struct info {
    int lc, rc, seg;
};
info operator +(const info &l, const info &r) {
    return (info){l.lc, r.rc, l.seg + r.seg + (l.rc != r.lc)};
}
struct node {
    info val;
    int t;
}seg[100010 << 2];
void settag(int i, int t) {
    seg[i].val = {t, t, 0};
    seg[i].t = t;
}
void pushdown(int i) {
    if (seg[i].t != 0) {
        settag(i << 1, seg[i].t);
        settag(i << 1 | 1, seg[i].t);
        seg[i].t = 0;
    }
}
void update(int i) {
    seg[i].val = seg[i << 1].val + seg[i << 1 | 1].val;
}
void buildtree(int i, int l, int r) {
    if (l == r) {
        seg[i].val = {w[id[l]], w[id[l]], 0};
        return;
    }
    int mid = l + r >> 1;
    buildtree(i << 1, l, mid);
    buildtree(i << 1 | 1, mid + 1, r);
    update(i);
}
void modify(int i, int l, int r, int x, int y, int k) {
    if (l == x && r == y) {
        settag(i, k);
        return;
    }
    pushdown(i);
    int mid = l + r >> 1;
    if (y <= mid) {
        modify(i << 1, l, mid, x, y, k);
    } else {
        if (x > mid) {
            modify(i << 1 | 1, mid + 1, r, x, y, k);
        } else {
            modify(i << 1, l, mid, x, mid, k);
            modify(i << 1 | 1, mid + 1, r, mid + 1, y, k);
        }
    }
    update(i);
}
info query(int i, int l, int r, int x, int y) {
    if (l == x && r == y) {
        return seg[i].val;
    }
    pushdown(i);
    int mid = l + r >> 1;
    if (y <= mid) {
        return query(i << 1, l, mid, x, y);
    } else {
        if (x > mid) {
            return query(i << 1 | 1, mid + 1, r, x, y);
        } else {
            return query(i << 1, l, mid, x, mid) + query(i << 1 | 1, mid + 1, r, mid + 1, y);
        }
    }
}
void dfs1(int u, int f) {
    sz[u] = 1;
    hs[u] = -1;
    fa[u] = f;
    dep[u] = dep[f] + 1;
    for (auto v : G[u]) {
        if (v != f) {
            dfs1(v, u);
            sz[u] += sz[v];
            if (hs[u] == -1 || sz[v] > sz[hs[u]]) {
                hs[u] = v;
            }
        }
    }
}
void dfs2(int u, int f) {
    top[u] = f;
    l[u] = ++tot;
    id[tot] = u;
    if (hs[u] != -1) {
        dfs2(hs[u], f);
    }
    for (auto v : G[u]) {
        if (v != fa[u] && v != hs[u]) {
            dfs2(v, v);
        }
    }
}
int query(int u, int v) {
    info ansu = {0, 0, -1}, ansv = {0, 0, -1};
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) {
            ansv = query(1, 1, n, l[top[v]], l[v]) + ansv;
            v = fa[top[v]];
        } else {
            ansu = query(1, 1, n, l[top[u]], l[u]) + ansu;
            u = fa[top[u]];
        }
    }
    if (dep[u] < dep[v]) {
        ansv = query(1, 1, n, l[u], l[v]) + ansv;
    } else {
        ansu = query(1, 1, n, l[v], l[u]) + ansu;
    }
    return ansu.seg + ansv.seg + (ansu.lc != ansv.lc) + 1;
}
void modify(int u, int v, int c) {
    while (top[u] != top[v]) {
        if (dep[top[u]] > dep[top[v]]) {
            swap(u, v);
        }
        modify(1, 1, n, l[top[v]], l[v], c);
        v = fa[top[v]];
    }
    if (dep[u] > dep[v]) {
        swap(u, v);
    }
    modify(1, 1, n, l[u], l[v], c);
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n >> q;
    for (int i = 1; i <= n; i++) {
        cin >> w[i];
    }
    for (int i = 1; i < n; i++) {
        int x, y;
        cin >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    dfs1(1, 0);
    dfs2(1, 1);
    buildtree(1, 1, n);
    while (q--) {
        string op;
        cin >> op;
        if (op[0] == 'C') {
            int a, b, c;
            cin >> a >> b >> c;
            modify(a, b, c);
        } else {
            int x, y;
            cin >> x >> y;
            cout << query(x, y) << '\n';
        }
    }
    return 0;
}

Distance Queries on a Tree

题意

​ 给定一棵树，需要完成以下两种操作：

  • 将第 i i i条边的边权改成 w w w
  • 查询 u u u到 v v v路径上的边权和
分析

​ 经典树链剖分+线段树的边权转点权问题，处理以上问题的方法就是把边权全部转移成子节点的点权，这样除了根节点的点权为0，其他节点的点权都是边权，在查询时如果 u u u和 v v v相等，说明是不走边的，特判为0。否则，在向上找LCA的时候是相同的过程，只不过找到相同LCA后，再查询是查询的 u u u的点权到 v v v的点权这条路径上的权值和，若 u u u比 v v v深，则 v v v的点权多加了一次，否则 u u u的点权多加了一次，所以最后一次查询，需要查询 l [ 浅的 ] + 1 l[浅的]+1 l[浅的]+1到 l [ 深的 ] l[深的] l[深的]，特判 l [ 浅的 ] + 1 ≤ l [ 深的 ] l[浅的]+1\leq l[深的] l[浅的]+1≤l[深的]。其他与正常树剖+线段树写法一样。

AC代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int n;
vector<pair<int, int> > G[200010];
struct edge {
    int u, v, w;
}e[200010];
int val[200010], hs[200010], fa[200010], dep[200010], sz[200010], top[200010], l[200010], r[200010], id[200010], tot;
struct info {
    LL sum;
};
info operator + (const info &l, const info &r) {
    return {l.sum + r.sum};
}
struct node {
    info val;
}sg[200010 << 2];
void update(int i) {
    sg[i].val = sg[i << 1].val + sg[i << 1 | 1].val;
}
void buildtree(int i, int l, int r) {
    if (l == r) {
        sg[i].val.sum = val[id[l]];
        return;
    }
    int mid = l + r >> 1;
    buildtree(i << 1, l, mid);
    buildtree(i << 1 | 1, mid + 1, r);
    update(i);
}
void modify(int i, int l, int r, int x, int k) {
    if (l == r) {
        sg[i].val.sum = k;
        return;
    }
    int mid = l + r >> 1;
    if (x <= mid) {
        modify(i << 1, l, mid, x, k);
    } else {
        modify(i << 1 | 1, mid + 1, r, x, k);
    }
    update(i);
}
LL query(int i, int l, int r, int x, int y) {
    if (l == x && r == y) {
        return sg[i].val.sum;
    }
    int mid = l + r >> 1;
    if (y <= mid) {
        return query(i << 1, l, mid, x, y);
    } else {
        if (x > mid) {
            return query(i << 1 | 1, mid + 1, r, x, y);
        } else {
            return query(i << 1, l, mid, x, mid) + query(i << 1 | 1, mid + 1, r, mid + 1, y);
        }
    }
}
LL query(int u, int v) {
    LL ans = 0;
    while (top[u] != top[v]) {
        if (dep[top[u]] < dep[top[v]]) {
            ans = ans + query(1, 1, n, l[top[v]], l[v]);
            v = fa[top[v]];
        } else {
            ans = ans + query(1, 1, n, l[top[u]], l[u]);
            u = fa[top[u]];
        }
    }
    if (dep[u] < dep[v]) {
        if (l[u] + 1 <= l[v]) {
            ans = ans + query(1, 1, n, l[u] + 1, l[v]);
        }
    } else {
        if (l[v] + 1 <= l[u]) {
            ans = ans + query(1, 1, n, l[v] + 1, l[u]);
        }
    }
    return ans;
}
void dfs1(int u, int f) {
    sz[u] = 1;
    hs[u] = -1;
    fa[u] = f;
    dep[u] = dep[f] + 1;
    for (auto v : G[u]) {
        if (v.first != f) {
            val[v.first] = v.second;
            dfs1(v.first, u);
            sz[u] += sz[v.first];
            if (hs[u] == -1 || sz[v.first] > sz[hs[u]]) {
                hs[u] = v.first;
            }
        }
    }
}
void dfs2(int u, int f) {
    top[u] = f;
    l[u] = ++tot;
    id[tot] = u;
    if (hs[u] != -1) {
        dfs2(hs[u], f);
    }
    for (auto v : G[u]) {
        if (v.first != fa[u] && v.first != hs[u]) {
            dfs2(v.first, v.first);
        }
    }
    r[u] = tot;
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n;
    for (int i = 1; i < n; i++) {
        cin >> e[i].u >> e[i].v >> e[i].w;
        G[e[i].u].push_back(make_pair(e[i].v, e[i].w));
        G[e[i].v].push_back(make_pair(e[i].u, e[i].w));
    }
    dfs1(1, 0);
    dfs2(1, 1);
    buildtree(1, 1, n);
    int q;
    cin >> q;
    while (q--) {
        int op;
        cin >> op;
        if (op == 1) {
            int x, w;
            cin >> x >> w;
            int u = e[x].u, v = e[x].v;
            if (fa[u] == v) {
                modify(1, 1, n, l[u], w);
            } else {
                modify(1, 1, n, l[v], w);
            }
        } else {
            int x, y;
            cin >> x >> y;
            if (x == y) {
                cout << "0\n";
            } else {
                cout << query(x, y) << '\n';
            }
        }
    }
    return 0;
}
eyuhaobanga
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
树链剖分详解
算法小猪的博客
08-13 1281
目录一、树链剖分相关概念1.为啥要剖分2.轻边和重边3.轻重边路径剖分的性质二、树链剖分的实现1.重链剖分 一、树链剖分相关概念 1.为啥要剖分 1.可以维护树路径上的信息(维护) 2.将一棵树划分成若干条链，用数据结构去维护每条链，复杂度为O(logN)O(logN)O(logN)。(复杂度低) 2.轻边和重边 将树中的边分为：轻边和重(zhong)边 定义size(x)size(x)size(x)为以xxx为根的子树的节点个数。 令vvv为xxx的儿子节点中sizesizesize值最大的节点，那么边(
树链剖分——重链剖分
zhaochuanfei666的博客
11-30 303
1.树链剖分的用处 对如下问题我们可以采用树链剖分的方法去做 1.把某个节点的子树的每个节点都加上一个值z 2.查询某个节点的子树的所有节点的值的和求出来 3.把一个节点x到y之间最短路径（经过边的条数最少）上的每个节点都加上某个值z 4.把一个节点x到y之间最短路径（经过边的条数最少）上的所有节点的和求出来 由于我们需要解决这些问题，所以我们要使用树链剖分这种算法。 2.实现原理： 1.知识储备： 重儿子：该节点的所有儿子中，子树中节点个数最多的儿子。 举例：节点A有两个儿子，G所形成的树中有6个结点分
树链剖分总结
ZhuRanCheng的博客
05-22 576
树链剖分总结
树链剖分 模板小记
绫
07-21 100
树链剖分 模板小记树链剖分~模板小记树链剖分 模板小记 Q.Q.Q. 树链剖分的背景？ A.A.A. 连通且无环的树 Q.Q.Q. 树链剖分的作用？ A.A.A. 大幅增加码量 （ A.A.A. 将一棵树变成几条链 树形变成线形 减少处理难度 Q.Q.Q. 树链剖分能处理哪些问题？ A1.A_1.A1​. 修改的有： 将xxx节点+ or×val+~or\times val+ or×val 将xxx到yyy这条路径上所有节点+ or×val+~or\t
树链剖分
xmr_pursue_dreams的博客
02-12 258
树链剖分 1.何为树链剖分？ 树链剖分能够通过轻重边将划分树上的链划分为轻链与重链，将树上路径操作转化为对每一个有影响的链进行操作，从而实现树上路径操作转化为多次区间操作。 2.走入树链剖分 树链剖分基于轻重边对树的划分。 下面给出一些定义： size[x]表示以x为根的子树的节点个数。 重儿子，指一个节点的所有儿子中size最大的节点；而其他儿子为轻儿子。 重边，指一个节点连接重...
树链剖分（重链剖分）
m0_73666576的博客
03-24 1674
本文主要针对于还没有学习过这个算法的新手同学
树链剖分模板题
qq_44335608的博客
10-03 155
树链剖分的学习，我是从树链剖分-1和树链剖分-2来学会的。 模板题 简单讲一下树链剖分吧，就是它首先第一遍dfs1,就将f[i] ,dep[i] ,sz[i] ,son[i]都预处理好，它们分别代表节点i的父节点，深度，子节点的数量，重节点;第二遍dfs2，就将id[i]，rk[i]，top[i]，分别代表节点i的dfs序，dfs序为i的节点，节点i所在链的顶端节点。如果你有lca和线段树的知识，...
树链剖分基础
墨染、青衣颜的博客
08-05 284
基本定义 把一棵树分成很多条链，然后利用数据结构（线段树、树状数组等）来维护这些链。 作用 树链剖分用于树路径信息维护。 剖分方式  随便剖分 随机剖分 轻重链剖分（本文） 轻重链剖分的基本概念 重结点：子树结点数目最多的结点； 轻节点：父亲节点中除了重结点以外的结点； 重边：父亲结点和重结点连成的边； 轻边：父亲节点和轻节点连成的边； 重链：由多条...
树链剖分 入门（求LCA）
qq_41418281的博客
08-25 2063
1. 引言   最近学了树链剖分基本思想，然后自己实现了遍代码，过了树链剖分求LCA，本文对树链剖分基本过程进行阐述，提出自己的看法，欢迎交流。 2.基本思想   顾名思义，树链剖分就是将树剖分成一条一条的链，之后快速的操作链。   树链剖分的复杂度为，预处理两边dfs，O(n)复杂度；之后查询或者修改操作每一条链为O(log(n))，因为剖分出来的链一共有log(n)条，当然如果在链上再套个线段树，那每次操作就是O(log2(n))。之后，下文只利用树链剖分求树上两点的最近公共最先，不涉及线段树，了解了基
树链剖分 简单讲解
Lee_w_j__的博客
01-29 237
如果我们想对一棵树上一个节点到另一个节点的路径进行求和，求极值，修改等操作，单单借助线段树是远远不够的，这个时候我们就需要借用树链剖分的帮助。 树链剖分，顾名思义，树链，指的是树上的路径，剖分就是把树上的各条路径分为重链，轻链。 套用卿学姐的话，树链剖分其实就是一个对树上属性进行hash的一个过程，将树型结构hash成链式结构，再将这些链放至线段树，树状数组等数据结构来解决问题。 学习树链剖
NOIP 树链剖分 NOIP 树链剖分
10-30
NOIP 树链剖分 NOIP 树链剖分
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
第5章 树链剖分 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第4部分 数据结构(提高篇)\ 第5章 树链剖分 测试数据
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5108
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
【代码随想录】【算法训练营】【第39天】 [62]不同路径 [63]不同路径II [343]整数拆分 [96]不同的二叉搜索树
weixin_54954007的博客
06-15 795
思路及算法思维，指路。题目来自。day 39，周六，坚持不住了~
算法篇-二叉树
最新发布
分享Java知识，记录思考和感悟
06-21 242
分享二叉树相关概念和算法题
代码随想录二刷DAY1~3
illuosion7的博客
06-16 1081
没做出来，发现问题了，滑动的应当是右指针for()里面填，这样一来，sum的初始化应当放到for的外面。//这句初始化很重要，我们要让反转后的最后一个元素指向nullptr，那么head的pre自然应该初始化为nullptr。题面：在一个排序的链表中，存在重复的节点，请删除该链表中重复的节点，重复的节点不保留。//条件也重要呀，不用判它的next，手写模拟就知道了。这题有难度，要求重复的节点不保留，显然需要三指针了。// 如果是最长，一发现不符合，就扩。//如果是最长，一发现不符合，就扩。
Aragorn 树链剖分
09-24
剖分完毕后，每条重链相当于一段区间，然后可以使用数据结构去维护整个树。具体过程是通过两次深度优先搜索来实现的：第一次DFS找出每个节点的子树大小和重儿子，第二次DFS连接重边形成重链。在重链上的节点使用数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值