bzoj 4034[HAOI2015]树上操作 - 树链剖分

4034: [HAOI2015]树上操作

Time Limit: 10 Sec  Memory Limit: 256 MB

Description

有一棵点数为 N 的树，以点 1 为根，且树点有边权。然后有 M 个

操作，分为三种：

操作 1 ：把某个节点 x 的点权增加 a 。

操作 2 ：把某个节点 x 为根的子树中所有点的点权都增加 a 。

操作 3 ：询问某个节点 x 到根的路径中所有点的点权和。

Input

第一行包含两个整数 N, M 。表示点数和操作数。接下来一行 N 个整数，表示树中节点的初始权值。接下来 N-1 

行每行三个正整数 fr, to ， 表示该树中存在一条边 (fr, to) 。再接下来 M 行，每行分别表示一次操作。其中

第一个数表示该操作的种类（ 1-3 ） ，之后接这个操作的参数（ x 或者 x a ） 。

Output

对于每个询问操作，输出该询问的答案。答案之间用换行隔开。

Sample Input

5 5
1 2 3 4 5
1 2
1 4
2 3
2 5
3 3
1 2 1
3 5
2 1 2
3 3

Sample Output

6
9
13

HINT

 对于 100% 的数据， N,M<=100000 ，且所有输入数据的绝对值都不会超过 10^6 。

 

一道树链剖分的练手题，以为一颗子树的DFS序是连续的，所以对子树的修改就相当于对一段区间的修改。

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL long long

using namespace std;

int N, M;
LL ans = 0;
const int MAXN = 2e5 + 10;
int size[MAXN], son[MAXN], top[MAXN], fa[MAXN], dfn[MAXN], out[MAXN];
LL val[MAXN];
int m[MAXN];
int head[MAXN], deep[MAXN];

int cnt = 0;
struct segment {
    LL val;
    LL len;
    LL lazy;
} seg[MAXN * 10];

struct edge {
    int v, next;
} g[MAXN * 2];

inline LL read()
{
    LL x = 0, w = 1; char ch = 0;
    while(ch < '0' || ch > '9') {
        if(ch == '-') {
            w = -1;
        }
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * w;
}

void pushdown(int root)
{
    seg[root * 2].lazy += seg[root].lazy;
    seg[root * 2 + 1].lazy += seg[root].lazy;
    seg[root * 2].val += seg[root * 2].len * seg[root].lazy;
    seg[root * 2 + 1].val += seg[root * 2 + 1].len * seg[root].lazy;
    seg[root].lazy = 0;
}

void pushup(int root)
{
    seg[root].val = seg[root * 2].val + seg[root * 2 + 1].val;
}

void build(int l, int r, int root)
{
    seg[root].len = r - l + 1;
    if(l == r) {
        seg[root].val = val[m[l]];
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, root * 2);
    build(mid + 1, r, root * 2 + 1);
    pushup(root);
}

void dfs1(int x)
{
    deep[x] = deep[fa[x]] + 1;
    size[x] = 1;
    for(int j = head[x]; j; j = g[j].next) {
        int to = g[j].v;
        if(fa[x] != to) {
            fa[to] = x;
            dfs1(to);
            size[x] += size[to];
            if(size[son[x]] < size[to]) {
                son[x] = to;
            }
        }
    }
}

void dfs2(int x, int tp)
{
    top[x] = tp;
    dfn[x] = ++cnt;
    m[cnt] = x;
    if(son[x]) {
        dfs2(son[x], tp);
    }
    for(int j = head[x]; j; j = g[j].next) {
        int to = g[j].v;
        if(!dfn[to]) {
            dfs2(to, to);
        }
    }
    out[x] = cnt;
}

void update(int ul, int ur, int l, int r, int root, LL k)
{
    if(ul <= l && ur >= r) {
        seg[root].val += seg[root].len * k;
        seg[root].lazy += k;
        return;
    }
    int mid = (l + r) >> 1;
    pushdown(root);
    if(mid >= ul) {
        update(ul, ur, l, mid, root * 2, k);
    }
    if(ur > mid) {
        update(ul, ur, mid + 1, r, root * 2 + 1, k);
    }
    pushup(root);
}

LL query(int ql, int qr, int l, int r, int root)
{
    if(ql <= l && qr >= r) {
        return seg[root].val;
    }
    pushdown(root);
    LL sum = 0;
    int mid = (l + r) >> 1;
    if(mid >= ql) {
        sum += query(ql, qr, l, mid, root * 2);
    }
    if(mid < qr) {
        sum += query(ql, qr, mid + 1, r, root * 2 + 1);
    }
    return sum;
}

void addedge(int u, int v)
{
    g[++cnt].v = v;
    g[cnt].next = head[u];
    head[u] = cnt;
}

LL cal(int x)
{
    LL sum = 0;
    while(top[x] != 1) {
        sum += query(dfn[top[x]], dfn[x], 1, N, 1);
        x = fa[top[x]];
    }
    sum += query(1, dfn[x], 1, N, 1);
    return sum;
}

int main()
{
    N = read(), M = read();
    for(int i = 1; i <= N; i++) {
        val[i] = read();
    }
    for(int i = 1; i < N; i++) {
        int u = read(), v = read();
        addedge(u, v);
        addedge(v, u);
    }
    cnt = 0;
    dfs1(1);
    dfs2(1, 1);
    build(1, N, 1);
/*    for(int i = 1; i <= N; i++) {
        cout<<dfn[i]<<" "<<out[i]<<endl;
    }*/
    for(int i = 1; i <= M; i++) {
        int opr = read();
        if(opr == 1) {
            LL x = read(), a = read();
            update(dfn[x], dfn[x], 1, N, 1, a);
        } else if(opr == 2) {
            LL x = read(), a = read();
            update(dfn[x], out[x], 1, N, 1, a);
        } else {
            int x = read();
            ans = cal(x);
            printf("%lld\n", ans);
        }
    }
    return 0;
}