树链剖分 入门题（洛谷）

最新推荐文章于 2022-09-14 11:47:41 发布
最新推荐文章于 2022-09-14 11:47:41 发布
阅读量394 收藏
点赞数
分类专栏： 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KXL5180/article/details/103901996
版权

最近学习了树链剖分。
发现这个东西其实并不是很难，而是因为代码量比较长，在码的过程中容易出错。
但不过其中还是用套路可循的，如果要学习树链剖分必须要知道DFS序和线段树。
这里就不详细讲了，只给出一些入门题，供个人参考。
https://www.luogu.com.cn/problem/P3384
这是一个模板题
首先树链剖分有两个dfs其中一个dfs是处理轻重儿子的，另外一个dfs是维护重链上的信息的，以及子树上的信息，因为优先处理重链的dfs序，因此链上信息可以区间处理，同时子树本身就可以用dfs序变成区间处理。同时处理树链上的信息，我觉得就是重链的合并。

#include "bits/stdc++.h"

using namespace std;
inline int read() {
    int x = 0;
    bool f = 1;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = 0;
    for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
    if (f) return x;
    return 0 - x;
}
typedef long long ll;
const int maxn = 200000 + 10;
const ll mod = 1000000000 + 7;
struct edge {
    int v, next;
} ed[maxn << 1];
struct node {
    int l, r, rs, ls, sum, lazy;
} t[maxn << 2];

int rt, n, m, r, p, val[maxn], cnt, head[maxn], top[maxn], id[maxn];
int f[maxn], dep[maxn], sz[maxn], son[maxn], rk[maxn];

void add_edge(int u, int v) {
    ++cnt;
    ed[cnt].v = v;
    ed[cnt].next = head[u];
    head[u] = cnt;
}
void dfs1(int u, int fa, int deep) {
    f[u] = fa, dep[u] = deep, sz[u] = 1;
    for (int i = head[u]; i; i = ed[i].next) {
        int v = ed[i].v;
        if (v == fa) continue;
        dfs1(v, u, deep + 1);
        sz[u] += sz[v];
        if (sz[v] > sz[son[u]]) son[u] = v;
    }
}
void dfs2(int u, int t) {
    top[u] = t, id[u] = ++cnt, rk[cnt] = u;
    if (!son[u]) return;
    dfs2(son[u], t);
    for (int i = head[u]; i; i = ed[i].next) {
        int v = ed[i].v;
        if (v != son[u] && v != f[u]) dfs2(v, v);
    }
}
#define lson t[o].ls
#define rson t[o].rs
void pushup(int o) {
    t[o].sum = (t[lson].sum + t[rson].sum) % p;
}
void build(int l, int r, int o) {
    t[o].l = l, t[o].r = r;
    if (l == r) {
        t[o].sum = val[rk[l]];
        return;
    }
    int mid = l + r >> 1;
    lson = ++cnt, rson = ++cnt;
    build(l, mid, lson);
    build(mid + 1, r, rson);
    pushup(o);
}
#define len(o) (t[o].r-t[o].l+1)

void pushdown(int o) {
    if (t[o].lazy) {
        int lz = t[o].lazy;
        t[lson].lazy = (t[lson].lazy + lz) % p;
        t[rson].lazy = (t[rson].lazy + lz) % p;
        t[lson].sum = (t[lson].sum + len(lson) * lz % p) % p;
        t[rson].sum = (t[rson].sum + len(rson) * lz % p) % p;
        t[o].lazy = 0;
    }
}
void update(int l, int r, int c, int o) {
    if (t[o].l >= l && t[o].r <= r) {
        t[o].lazy = (t[o].lazy + c) % p;
        t[o].sum = (t[o].sum + c * len(o) % p) % p;
        return;
    }
    pushdown(o);
    int mid = (t[o].l + t[o].r) >> 1;
    if (l <= mid) update(l, r, c, lson);
    if (r > mid) update(l, r, c, rson);
    pushup(o);
}
int query(int l, int r, int o) {
    if (t[o].l >= l && t[o].r <= r) return t[o].sum;
    pushdown(o);
    int mid = (t[o].l + t[o].r) >> 1;
    int ret = 0;
    if (l <= mid) ret += query(l, r, lson);
    if (r > mid) ret += query(l, r, rson);
    return ret % p;
}
void modify(int x, int y, int c) {
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]])
            swap(x, y);
        update(id[top[x]], id[x], c, rt);
        x = f[top[x]];
    }
    if (id[x] > id[y]) swap(x, y);
    update(id[x], id[y], c, rt);
}
int sum(int x, int y) {
    int ret = 0;
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]])
            swap(x, y);
        ret = (ret + query(id[top[x]], id[x], rt)) % p;
        x = f[top[x]];
    }
    if (id[x] > id[y]) swap(x, y);
    return (ret + query(id[x], id[y], rt)) % p;
}

int main() {
    scanf("%d%d%d%d", &n, &m, &r, &p);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &val[i]);
    }
    int x, y;
    for (int i = 1; i < n; i++) {
        scanf("%d%d", &x, &y);
        add_edge(x, y), add_edge(y, x);
    }
    cnt = 0;
    dfs1(r, 0, 0);
    dfs2(r, r);
    cnt = 0;
    build(1, n, rt = cnt);
    int op, k;
    for (int i = 1; i <= m; i++) {
        scanf("%d", &op);
        if (op == 1) {
            scanf("%d%d%d", &x, &y, &k);
            modify(x, y, k);
        } else if (op == 2) {
            scanf("%d%d", &x, &y);
            printf("%d\n", sum(x, y));
        } else if (op == 3) {
            scanf("%d%d", &x, &y);
            update(id[x], id[x] + sz[x] - 1, y, rt);
        } else {
            scanf("%d", &x);
            printf("%d\n", query(id[x], id[x] + sz[x] - 1, rt));
        }
    }
    return 0;
}

https://www.luogu.com.cn/problem/P2146
P2146 [NOI2015]软件包管理器
这道题也不难，知道线段树维护什么，线段树应维护一个区间有多个没有安装和安装了多少个，安装一个就是询问结点到根有多少个没有安装。卸载一个就是询问子树安装了多少个。

#include "bits/stdc++.h"

using namespace std;
inline int read() {
    int x = 0;
    bool f = 1;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = 0;
    for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
    if (f) return x;
    return 0 - x;
}
typedef long long ll;
const int maxn = 200000 + 10;
const ll mod = 1000000000 + 7;
struct edge {
    int v, next;
} ed[maxn << 1];
struct node {
    int l, r, rs, ls, sum, lazy;
} a[maxn << 2];

int rt, n, m, val[maxn], cnt, head[maxn], top[maxn], id[maxn];
int f[maxn], dep[maxn], sz[maxn], son[maxn], rk[maxn];

void add_edge(int u, int v) {
    ++cnt;
    ed[cnt].v = v;
    ed[cnt].next = head[u];
    head[u] = cnt;
}
void dfs1(int u, int fa, int deep) {
    sz[u] = 1, f[u] = fa, dep[u] = deep;
    for (int i = head[u]; i; i = ed[i].next) {
        int v = ed[i].v;
        if (v == fa) continue;
        dfs1(v, u, deep + 1);
        sz[u] += sz[v];
        if (sz[v] > sz[son[u]])
            son[u] = v;
    }
}
void dfs2(int u, int t) {
    top[u] = t, id[u] = ++cnt, rk[cnt] = u;
    if (!son[u]) return;
    dfs2(son[u], t);
    for (int i = head[u]; i; i = ed[i].next) {
        int v = ed[i].v;
        if (v != son[u] && v != f[u])
            dfs2(v, v);
    }
}
#define lson a[o].ls
#define rson a[o].rs
#define len(o) (a[o].r-a[o].l+1)

void pushup(int o) {
    a[o].sum = a[lson].sum + a[rson].sum;
}
void build(int l, int r, int o) {
    a[o].l = l, a[o].r = r;
    a[o].lazy = -1;
    if (l == r) return;
    int mid = l + r >> 1;
    lson = ++cnt, rson = ++cnt;
    build(l, mid, lson);
    build(mid + 1, r, rson);
}
void pushdown(int o) {
    if (a[o].lazy != -1) {
        a[lson].lazy = a[rson].lazy = a[o].lazy;
        a[lson].sum = len(lson) * a[o].lazy;
        a[rson].sum = len(rson) * a[o].lazy;
        a[o].lazy = -1;
    }
}
void update(int l, int r, int o, int f) {
    if (a[o].l >= l && a[o].r <= r) {
        a[o].lazy = f;
        a[o].sum = f * len(o);
        return;
    }
    pushdown(o);
    int mid = a[o].l + a[o].r >> 1;
    if (l <= mid) update(l, r, lson, f);
    if (r > mid) update(l, r, rson, f);
    pushup(o);
}
int query(int l, int r, int o) {
    if (a[o].l >= l && a[o].r <= r) {
        return len(o) - a[o].sum;
    }
    pushdown(o);
    int mid = a[o].l + a[o].r >> 1, ret = 0;
    if (l <= mid) ret += query(l, r, lson);
    if (r > mid) ret += query(l, r, rson);
    return ret;
}
int sum(int x, int y) {
    int ret = 0;
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]])
            swap(x, y);
        ret += query(id[top[x]], id[x], rt);
        x = f[top[x]];
    }
    if (id[x] > id[y]) swap(x, y);
    return ret + query(id[x], id[y], rt);
}
void modify(int x, int y, int c) {
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]])
            swap(x, y);
        update(id[top[x]], id[x], rt, c);
        x = f[top[x]];
    }
    if (id[x] > id[y]) swap(x, y);
    update(id[x], id[y], rt, c);
}
int main() {
//    scanf("%d", &n);
    n = read();
    int x;
    for (int i = 1; i < n; i++) {
//        scanf("%d", &x);
        x = read();
        add_edge(x + 1, i + 1);
        add_edge(i + 1, x + 1);
    }
    cnt = 0;
    dfs1(1, 0, 0);
    dfs2(1, 1);
    cnt = 0;
    build(1, n, rt = cnt);
//    scanf("%d", &m);
    m = read();
//    string tmp;
    char tmp[11];
    for (int i = 1; i <= m; i++) {
        scanf("%s", tmp);
        x = read();
        if (tmp[0] == 'i') {
            x++;
            printf("%d\n", sum(1, x));
            modify(1, x, 1);
        } else {
            x++;
            printf("%d\n", sz[x] - query(id[x], id[x] + sz[x] - 1, rt));
            update(id[x], id[x] + sz[x] - 1, rt, 0);
        }
    }
    return 0;
}

https://www.luogu.com.cn/problem/P2590
P2590 [ZJOI2008]树的统计
这道题也是一个模板题，线段树维护最大值和区间和就可以了。代码就不贴了，只需要稍微改一改上面的代码。
https://www.luogu.com.cn/problem/P3258
P3258 [JLOI2014]松鼠的新家
这道题也是一个模板题，每条链加上1，然后询问每一个点就可以了。
https://www.luogu.com.cn/problem/P3178
P3178 [HAOI2015]树上操作
这道题可能还没有模板题难。
https://www.luogu.com.cn/problem/P2486
P2486 [SDOI2011]染色
这道题思路不难想到，但不过你不仅仅要考虑线段树中合并时可能颜色相同，你还有考虑链合并时颜色 相同。

#include "bits/stdc++.h"

using namespace std;
inline int read() {
    int x = 0;
    bool f = 1;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = 0;
    for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
    if (f) return x;
    return 0 - x;
}
typedef long long ll;
const int maxn = 100000 + 10;
const ll mod = 1000000000 + 7;
struct edge {
    int v, next;
} ed[maxn << 1];
struct node {
    int l, r, rs, ls;
    int lc, rc, sum, lazy;
} a[maxn << 2];

int rt, n, m, val[maxn], cnt, head[maxn], top[maxn], id[maxn];
int f[maxn], dep[maxn], sz[maxn], son[maxn], rk[maxn];

void add_edge(int u, int v) {
    ++cnt;
    ed[cnt].v = v;
    ed[cnt].next = head[u];
    head[u] = cnt;
}
void dfs1(int u, int fa, int deep) {
    sz[u] = 1, f[u] = fa, dep[u] = deep;
    for (int i = head[u]; i; i = ed[i].next) {
        int v = ed[i].v;
        if (v == fa) continue;
        dfs1(v, u, deep + 1);
        sz[u] += sz[v];
        if (sz[v] > sz[son[u]]) son[u] = v;
    }
}
void dfs2(int u, int t) {
    top[u] = t, id[u] = ++cnt, rk[cnt] = u;
    if (!son[u]) return;
    dfs2(son[u], t);
    for (int i = head[u]; i; i = ed[i].next) {
        int v = ed[i].v;
        if (v != f[u] && v != son[u]) dfs2(v, v);
    }
}

#define lson a[o].ls
#define rson a[o].rs
#define len(o) (a[o].r-a[o].l+1)

void pushup(int o) {
    a[o].sum = a[lson].sum + a[rson].sum;
    if (a[lson].rc == a[rson].lc) a[o].sum--;
    a[o].lc = a[lson].lc;
    a[o].rc = a[rson].rc;
}
void build(int l, int r, int o) {
    a[o].l = l, a[o].r = r, a[o].lazy = 0;
    if (l == r) {
        a[o].lc = a[o].rc = val[rk[l]];
        a[o].sum = 1;
        return;
    }
    int mid = l + r >> 1;
    a[o].ls = ++cnt, a[o].rs = ++cnt;
    build(l, mid, lson);
    build(mid + 1, r, rson);
    pushup(o);
}

void up(int o, int lz) {
    a[o].lazy = lz;
    a[o].lc = a[o].rc = lz;
    a[o].sum = 1;
}

void pushdown(int o) {
    if (a[o].lazy) {
        up(lson, a[o].lazy);
        up(rson, a[o].lazy);
        a[o].lazy = 0;
    }
}
void update(int l, int r, int o, int c) {
    if (a[o].l >= l && a[o].r <= r) {
        up(o, c);
        return;
    }
    pushdown(o);
    int mid = a[o].l + a[o].r >> 1;
    if (l <= mid) update(l, r, lson, c);
    if (r > mid) update(l, r, rson, c);
    pushup(o);
}
int query(int l, int r, int o) {
    if (a[o].l == l && a[o].r == r) {
        return a[o].sum;
    }
    pushdown(o);
    int mid = a[o].l + a[o].r >> 1, ret = 0;
    if (r <= mid) ret = query(l, r, lson);
    else if (l > mid) ret = query(l, r, rson);
    else {
        ret = query(l, mid, lson) + query(mid + 1, r, rson);
        if (a[lson].rc == a[rson].lc) ret--;
    }
    return ret;
}
int cquery(int o, int p) {
    if (a[o].l == a[o].r) return a[o].lc;
    pushdown(o);
    int mid = a[o].l + a[o].r >> 1;
    if (p <= mid) return cquery(lson, p);
    else return cquery(rson, p);
}
void modify(int x, int y, int c) {
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]])
            swap(x, y);
        update(id[top[x]], id[x], rt, c);
        x = f[top[x]];
    }
    if (id[x] > id[y]) swap(x, y);
    update(id[x], id[y], rt, c);
}
int sum(int x, int y) {
    int ret = 0, last1 = -1, last2 = -1;
    int LC = 0, RC = 0;
    while (top[x] != top[y]) {
        if (dep[top[x]] < dep[top[y]])
            swap(x, y), swap(last1, last2);
        ret += query(id[top[x]], id[x], rt);
        LC = cquery(rt, id[top[x]]);
        RC = cquery(rt, id[x]);
        if (RC == last1) ret--;
        last1 = LC;
        x = f[top[x]];
    }
    if (id[x] > id[y]) swap(x, y), swap(last1, last2);
    ret += query(id[x], id[y], rt);
    LC = cquery(rt, id[x]);
    RC = cquery(rt, id[y]);
    if (LC == last1) ret--;
    if (RC == last2) ret--;
    return ret;
}

int main() {
    n = read(), m = read();
    for (int i = 1; i <= n; i++) {
        val[i] = read();
    }
    int x, y, z;
    for (int i = 1; i < n; i++) {
        x = read(), y = read();
        add_edge(x, y);
        add_edge(y, x);
    }
    cnt = 0;
    dfs1(1, 0, 0);
    dfs2(1, 1);
    cnt = 0;
    build(1, n, rt = cnt);
    char op[10];
    while (m--) {
        scanf("%s", op);
        x = read(), y = read();
        if (op[0] == 'C') {
            z = read();
            modify(x, y, z);
        } else {
            printf("%d\n", sum(x, y));
        }
    }
    return 0;
}
KXL5180
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
洛谷P3384 【模板】树链剖分
Mr_Kingk的博客
08-14 226
题目描述 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4： 格式： 4 x 表示求以x为根节点的子树...
树链剖分（含例题）
zyc_____的博客
05-04 400
树链剖分介绍： 模板题：【模板】最近公共祖先（LCA） - 洛谷 图片来自：通俗易懂的树链剖分详解 - 一剑缥缈的洛咕博客 - 洛谷博客 树链剖分的优点： 求LCA中的优化无非就是减少无效搜索的次数，树链剖分把树拆成不同的链（保证不重不漏），因为两个点的LCA一定在一条链上（同一个点），所以如果搜索到的点不在同一条链上，那么不是倍增跳或是······，而是跳过一整条链，这样搜索的速度会大幅提高。 注释代码： #include<bits/stdc++.h> using names.
P3401 洛谷树 (树链剖分) 好题
Fau的博客
11-03 366
题目链接: P3401 洛谷树 大致题意 给定一棵有nnn个节点的树, 每条边有边权wiw_iwi​. 有mmm次如下操作: 1 a b 询问a,ba, ba,b路径上, 所有子路径边权异或和的和. 2 a b c把(a,b)(a, b)(a,b)这条边的权值修改为ccc. 特别的, 每一时刻树中边权均∈[0,1023]\in[0, 1023]∈[0,1023] 解题思路 思维 首先对于树上问题, 我们考虑化为序列问题求解. 我们发现并不好在10进制下处理出所有区间异或和. 因此考虑拆位. 到此, 我
洛谷 P3384 树链剖分(详解)
riba2534的博客
07-12 3942
题目描述 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4： 格...
洛谷P4116 Qtree3（树链剖分）
qq_36018057的博客
09-14 196
对于本题，可以考虑维护一条链上最早出现的那个黑点(深度最浅),对于多次操作的树上题目,都最好考虑下以下个人发现的一个思路.对于方法2,常常会用到树上差分,树链剖分等技巧。这代码确实太长了,有一个地方写错都得查找很久。1.考虑在数组（一条链）上怎么实现,使用树链剖分实现,线段树维护两个值。2.考虑把数组的情况扩展到树上.,表示这一个区间最浅的黑点是。
树链剖分模板题
05-19
#include #include #include #define N 30003 #define INF 2147483647 using namespace std; int n,f[N][20],dep[N],siz[N],son[N],top[N],tot,pos[N],w[N]; int Max[N*4],Sum[N*4];...vector <int> to[N];...
NOIP 树链剖分 NOIP 树链剖分
10-30
NOIP 树链剖分 NOIP 树链剖分
NOIP树链剖分习题讲解报告
11-01
P2590 [ZJOI2008]树的统计 P3384 【模板】轻重链剖分/树链剖分 P3950 部落冲突 P4092 [HEOI2016/TJOI2016]树 P2146 [NOI2015] 软件包管理器
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
树链剖分习题.pptx
最新发布
01-30
关于树链剖分cabzoj上面的题解
树链剖分题集
帅比王的博客
10-12 1452
树链剖分常用于处理静态树上操作，效率很高，写起来也就是固定的轻重边拆分+线段树，但是代码一般都是100行+，容易出错。 本题集中的树链剖分练习题，在解决思路上没什么难点，主要是如何设计线段树以及如何更新+询问，也就是说要想好怎么维护线段树，其它地方没什么太难的，但是代码长就容易出bug，多写写就好了。最后一题是线段树动态开点，这和可持久化权值线段树（动态主席树）一样的思想，只需要将普通的线段树给稍...
[LNOI2014]LCA--树链剖分例练习
weixin_45772744的博客
04-01 906
题目链接: A-[LNOI2014]LCA_牛客竞赛数据结构专题班树链剖分 (nowcoder.com) 题意: 1≤n≤50000,1≤m≤50000 样例: 输入 5 2 0 0 1 1 1 4 3 1 4 2 输出 8 5 思路: 本题的关键在于深度的一个巧妙转化，我们假设树上所有点的初始权值为0，对于点x，我们将从根节点到x路径上所有点的点权加1，对于x和z的最近公共祖先的深度就是从根节点到z的路径上的点权之和，自己也可以在纸上画画。 明确了这个转化之后，对于[l.
洛谷 P3384 【模板】树链剖分
邵光亮的博客
08-16 601
题目描述 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4： 格式： 4 x 表示求以x为根节点的子...
洛谷P2146【线段树】【树链剖分】
willem248的博客
08-01 100
代码】洛谷P2146【线段树】【树链剖分】
树链剖分专题训练及相应题目总结（洛谷）
weixin_45677913的博客
04-10 535
树链剖分练习题（原题单链接） 最近花了一点时间完成了前不久题单还剩下的一些部分，现在小小的做一个总结，个人感觉树链剖分题目类型还是很有规律的，都是可以做的，可能我还遇到特别难得题吧。我觉得树链剖分最主要的就是怎么与线段树结合将路径信息转变成区间线段信息，以及在线段树中懒标记的使用，而且树链剖分代码量有点大，所以需要很细心。 [USACO11DEC]Grass Planting G 这道题就是把边权...
专题·树链剖分【including 洛谷·【模板】树链剖分
樱狸✨愿携清风归来处
05-03 6334
初见安~~~终于学会了树剖~~~ 【兴奋】当初机房的大佬在学树剖的时候我反复强调过：“学树剖没有前途的！！！” 恩。真香。 一、重链与重儿子 所谓树剖——树链剖分，就是赋予一个链的概念来优化一些或者说是应对一些操作的，所以相应的会有一些专用的概念定义。 一个节点的重儿子，为其更大的一颗子树的根节点。从这个点连向重儿子的边我们称为重边。 这里我们定义子树的大小是取决于节点的数量，而...
「洛谷P3384」树链剖分
wzw
05-29 194
题目描述 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4： 格式： 4 x 表示求以x为根节点的子树内所有节...
树链剖分-入门题目
CodeDream
11-12 1345
Query on a tree 题目链接: http://vjudge.net/problem/SPOJ-QTREE 题目大致意思就是: 给你一棵树,有连个操作:       ● 第一个是查询任意两个不同节点上的最短路径上的最大权边!       ● 第二个操作修改某一条边的权值; 对于一棵树,数的深度如果很大,那么每次查询两个叶子节点,时间复杂度还是很高的。所以我们就把树分成一
洛谷 P4116 Qtree3（树剖）
C_Dreamy的博客
01-21 141
题目中默认根为 1，

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值