BZOJ-4034: [HAOI2015]树上操作 （树链剖分 入门题 子树整体修改 线段树 区间修改+查询）

4034: [HAOI2015]树上操作

Time Limit: 10 Sec   Memory Limit: 256 MB
Submit: 5744   Solved: 1843
[ Submit][ Status][ Discuss]

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 。

#include <bits/stdc++.h>
using namespace std;
#define maxn 100005
int a[maxn], sz[maxn], dep[maxn], id[maxn], val[maxn], son[maxn], mx[maxn], top[maxn], pre[maxn], tot;
vector<vector<int> >g(maxn);
struct tree{
	long long sm, lazy;
}c[maxn * 4];
void dfs(int x, int fa, int d){
	sz[x] = 1;
	pre[x] = fa;
	dep[x] = d;
	son[x] = 0;
	int cur;
	for(int i = 0; i < g[x].size(); ++i){
		cur = g[x][i];
		if(cur == fa) continue;
		dfs(cur, x, d + 1);
		sz[x] += sz[cur];
		if(sz[son[x]] < sz[cur]){
			son[x] = cur;
		}
	}
}
void dfs1(int x, int tp){
	id[x] = ++tot;
	top[x] = tp;
	if(son[x]){
		dfs1(son[x], tp);
	}
	int cur;
	for(int i = 0; i < g[x].size(); ++i){
		cur = g[x][i];
		if(cur == pre[x] || cur == son[x]) continue;
		dfs1(cur, cur);
	}
	mx[x] = tot;
}
void build(int o, int l, int r){
	c[o].lazy = 0;
	if(l == r){
		c[o].sm = val[l];
		return;
	}
	int mid = l + r >> 1;
	build(o << 1, l, mid);
	build(o << 1 | 1, mid + 1, r);
	c[o].sm = c[o << 1].sm + c[o << 1 | 1].sm;
}
void pushdown(int o, int l, int r){
	if(l == r || c[o].lazy == 0) return;
	int mid = l + r >> 1;
	c[o << 1].lazy += c[o].lazy;
	c[o << 1 | 1].lazy += c[o].lazy;
	c[o << 1].sm += c[o].lazy * (mid - l + 1);
	c[o << 1 | 1].sm += c[o].lazy * (r - mid);
	c[o].lazy = 0;
}
long long query(int o, int l, int r, int L, int R){
	pushdown(o, l, r);
	if(l >= L && r <= R){
		return c[o].sm;
	}
	int mid = l + r >> 1;
	long long ans = 0;
	if(mid >= L) ans += query(o << 1, l, mid, L, R);
	if(mid < R) ans += query(o << 1 | 1, mid + 1, r, L, R);
	return ans;
}
long long getsm(int x){
	int tp = top[x];
    long long ans = 0;
    while(tp != 1){
        ans += query(1, 1, tot, id[tp], id[x]);
        x = pre[tp];
        tp = top[x];
    }
    ans += query(1, 1, tot, 1, id[x]);
    return ans;
}
void add(int o, int l, int r, int L, int R, int v){
	pushdown(o, l, r);
	if(l >= L && r <= R){
		c[o].lazy += v;
		c[o].sm += 1LL * v * (r - l + 1);
		return;
	}
	int mid = l + r >> 1;
	if(mid >= L) add(o << 1, l, mid, L, R, v);
	if(mid < R) add(o << 1 | 1, mid + 1, r, L, R, v);
	c[o].sm = c[o << 1].sm + c[o << 1 | 1].sm;
}
int main(){
	int n, m, u, v, op;
	scanf("%d %d", &n, &m);
	for(int i = 1; i <= n; ++i){
		scanf("%d", &a[i]);
	}
	for(int i = 1; i < n; ++i){
		scanf("%d %d", &u, &v);
		g[u].push_back(v);
		g[v].push_back(u);
	}
	tot = 0;
	dfs(1, 0, 1);
	dfs1(1, 1);
	for(int i = 1; i <= n; ++i){
		val[id[i]] = a[i];
	}
	build(1, 1, tot);
	for(int i = 1; i <= m; ++i){
		scanf("%d", &op);
		if(op == 1){
			scanf("%d %d", &u, &v);
			add(1, 1, tot, id[u], id[u], v);
		}
		else if(op == 2){
			scanf("%d %d", &u, &v);
			add(1, 1, tot, id[u], mx[u], v);
		}
		else{
			scanf("%d", &u);
			printf("%lld\n", getsm(u));
		}
	}
}

/*
题意：一棵树，1e5个节点，每个节点有权值，1e5次操作，每次操作要么修改某节点的值，
要么修改节点以及其子树中所有点的值，要么询问某点到根路径上所有点的权值和。

思路：
树链剖分的裸题，在线段树上做区间的修改和查询操作，对于修改子树中所有点的操作，关键
在于怎么把子树上所有的点对应到线段树上，其实一颗子树中所有点所在区间就是其中节点的
最小标号到最大标号，dfs性质决定的，知道这个就简单了，维护一下最大标号即可，最小标号
就是根节点自己。单点修改和路径和查询就是基本操作了。
*/