树链剖分 入门题（洛谷）

最新推荐文章于 2021-11-03 16:58:11 发布
最新推荐文章于 2021-11-03 16:58:11 发布
阅读量423 收藏
点赞数
分类专栏： 线段树
版权声明：本文为博主原创文章，遵循 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
关注
专栏目录
【洛谷 P3384】树链剖分【详解树链剖分】
Gene_I must wait for the sunrise
03-15 2490
题意： 一颗 NNN 个节点的树，每个节点上都有初始权值。现在有四种操作： 操作 111 —— 1&nbsp;x&nbsp;y&nbsp;z1\ x\ y\ z1&nbsp;x&nbsp;y&nbsp;z，表示将 xxx 到 yyy 节点最短路径上所有节点的值加z 操作 222 —— 2&nbsp;x&nbsp;y2\ x\ y2&nbsp;x&nbsp;y，表示求 xxx 到 yyy 节点最短路...
树链剖分-入门题目
CodeDream
11-12 1399
Query on a tree 题目链接: http://vjudge.net/problem/SPOJ-QTREE 题目大致意思就是: 给你一棵树,有连个操作:       ● 第一个是查询任意两个不同节点上的最短路径上的最大权边!       ● 第二个操作修改某一条边的权值; 对于一棵树,数的深度如果很大,那么每次查询两个叶子节点,时间复杂度还是很高的。所以我们就把树分成一
「洛谷P3384」树链剖分
wzw
05-29 208
题目描述 如题，已知一棵包含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为根节点的子树内所有节...
树链剖分专题训练及相应题目总结（洛谷）
weixin_45677913的博客
04-10 556
树链剖分练习题（原题单链接） 最近花了一点时间完成了前不久题单还剩下的一些部分，现在小小的做一个总结，个人感觉树链剖分题目类型还是很有规律的，都是可以做的，可能我还遇到特别难得题吧。我觉得树链剖分最主要的就是怎么与线段树结合将路径信息转变成区间线段信息，以及在线段树中懒标记的使用，而且树链剖分代码量有点大，所以需要很细心。 [USACO11DEC]Grass Planting G 这道题就是把边权...
洛谷 P3384 树链剖分(详解)
riba2534的博客
07-12 3985
题目描述 如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和 操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z 操作4： 格...
NOIP 树链剖分 NOIP 树链剖分
10-30
### NOIP 树链剖分知识点详解 #### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了更高效地处理树状结构上的路径信息维护问题，例如路径上的权值更新或查询等操作。通过树链剖分，可以将这些操作...
树链剖分模板题
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树链剖分习题讲解报告
11-01
此题同样是关于树链剖分的应用，但涉及的操作更为复杂。除了基本的树链剖分外，还需要额外考虑如何高效地更新节点值以及求解子树的和。具体的解决方案包括： 1. **预处理阶段：** - 计算每个节点的深度、子树大小...
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
P3401 洛谷树 (树链剖分) 好题
Fau的博客
11-03 411
题目链接: 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进制下处理出所有区间异或和. 因此考虑拆位. 到此, 我
poj3237tree【树链剖分入门题+线段树】
MissZhou要努力
01-23 1529
休息了两天，今天开始做树链剖分，除了模板长以外，还是挺好理解的。就只是线段树+剖分独特的函数，然后树链剖分所用的数组有点多，没了。其中需要注意的一个点是“链”（路径）不一定是从根节点到叶子节点的，轻儿子这个点它也有重儿子啊啊啊。 再说这个题，单点更新，区间取相反数，区间求最大值。 /*********** poj3237 2015.1.23 2504K 657MS C++ 6396B ****
专题·树链剖分【including 洛谷·【模板】树链剖分
樱狸✨愿携清风归来处
05-03 6399
初见安~~~终于学会了树剖~~~ 【兴奋】当初机房的大佬在学树剖的时候我反复强调过：“学树剖没有前途的！！！” 恩。真香。 一、重链与重儿子 所谓树剖——树链剖分，就是赋予一个链的概念来优化一些或者说是应对一些操作的，所以相应的会有一些专用的概念定义。 一个节点的重儿子，为其更大的一颗子树的根节点。从这个点连向重儿子的边我们称为重边。 这里我们定义子树的大小是取决于节点的数量，而...
树链剖分 讲解+模板+习题
Hacheylight
08-08 488
今天我们来讲一下树链剖分 树链剖分是什么？ 树链剖分是一种用来维护树上路径信息的在线方法，可以处理在线。 通常通过一种方法，将一棵树剖分成若干条链，然后通过数据结构（线段树，BIT等）去维护。 我们通常所说的树链剖分，基本都是轻重链剖分。 下面我们介绍一下这一种剖分。 学习树链剖分的基础知识有lca，dfs序，线段树等。 首先，我们来明确即可变量。 sizeisizeisize_i...
树链剖分（ 洛谷P3384 ）
12-17 102
我们有时候遇到这样一类题目，让我们维护树上路径的某些信息，这个时候发现我们无法用线段树或者树状数组来维护这些信息，那么我们就有着一种新的数据结构，树剖：将一棵树划分成若干条链，用数据结构去维护每条链，复杂度为O(logN)。 剖分方法： 盲目剖分 随机剖分 启发式剖分综合比较，启发式剖分是剖分时的最佳选择。 将树中的边分为：轻边和重边 定义size(X)为以X为...
洛谷P1505 [国家集训队]旅游（树剖+线段树）
weixin_34194087的博客
10-16 123
传送门 这该死的码农题…… 把每一条边变为它连接的两个点中深度较浅的那一个，然后就是一堆单点修改/路径查询，不讲了 这里就讲一下怎么搞路径取反，只要打一个标记就好了，然后把区间和取反，最大最小值交换然后再取反 单点修改的时候忘记pushdown结果调了好久…… 1 //minamoto 2 #include<bits/stdc++.h> 3 #def...
【洛谷P3384】树链剖分
weixin_30565199的博客
03-10 79
这是一道树链剖分的模板题，首先要学会线段树、dfs、链式前向星之类的，不然……//打暴力吧 本题很考验代码能力，难度不大，主要是细节繁多。（我调了1h） 树链剖分的原理不再赘述（详见《信息学奥赛一本通·提高版》），主要说一下一些容易错的细节。 ps：本人树链剖分的写法来源于《信息学奥赛一本通·提高版》，如有漏洞，欢迎指责。 1 #include <iostream>...
树链剖分例题
hutwuguangrong的博客
05-14 331
非常好的一个博客http://www.cnblogs.com/chinhhh/p/7965433.html 权值在边，将权值映射在边的儿子节点就ok了 以下题目来自 kuangbin 这些题目套上树链剖分的模板，感觉考的就是线段树的知识 P3384 【模板】树链剖分 （点） 题意： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 2 x y 表示求树从x到y结点...
【例题】【树链剖分】
ANG
12-25 745
1、 【USACO 2011 Dec Gold 】种草 时间限制 : 10000 MS 空间限制 : 65536 KB问题描述 农夫约翰有N块贫瘠的牧场(2 <= N <= 100,000)，有N-1条双向道路将这N个牧场连接了起来，每两个牧场间都有且仅有一条路径可相互到达。著名奶牛贝西经常抱怨：为什么连接牧场的道路上没有草可吃呢? 约翰非常喜欢贝西，今天约翰终于决定要在道路上种草了。约
树链剖分习题
tangzhide123yy的博客
10-17 295
树链剖分习题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值