bzoj 4034 树上操作 （树链剖分 + 线段树）

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

有位大佬写了两种方法，在这里膜膜Ta。我这里用的是top数组存，节点在轻重链上的top不同。如果在重链上，则top会直接到它所在重链的父亲节点。如果在轻链上，则top为它自己，但因为重链上的top直接连到父亲节点且这一条链就是该节点到根节点的必经之路，所以可以利用该性质在线段树中一段一段地求解。具体可再参见大佬的博客。

#include <cstdio>
#include <cstring>
#include <algorithm>
#define LL long long
using namespace std;

const int N = 400010;

struct Edge {
	int v, next;
} edge[N];

struct Node {
	LL sum, flag;
	Node *ls, *rs;
	void pushdown(int l, int r) {
		if(flag) {
			int mid = (l + r) >> 1;
			ls->flag += flag;
			ls->sum += (LL) (mid - l + 1) * flag;
			rs->flag += flag;
			rs->sum += (LL) (r - mid) * flag;
			flag = 0;
		}
	}
	void update() {
		sum = ls->sum + rs->sum;
	}
} pool[N], *tail = pool, *root;

int n, m, a[N], A[N];
int num = 0, head[N];
int indexx = 0, fa[N], dep[N], siz[N], son[N], top[N], in[N], out[N];

void zero() {
	memset(son, -1, sizeof(son));
}

void add(int u, int v) {
	num ++;
	edge[num].v = v;
	edge[num].next = head[u];
	head[u] = num;
}

void dfs1(int u, int f, int d) {
	fa[u] = f;
	dep[u] = d;
	siz[u] = 1;
	for(int i = head[u]; i; i = edge[i].next) {
		int v = edge[i].v;
		if(v == f) continue;
		dfs1(v, u, d + 1);
		siz[u] += siz[v];
		if(son[u] == -1 || siz[son[u]] < siz[v])
			son[u] = v;
	}
}

void dfs2(int u, int tp) {
	top[u] = tp;
	in[u] = out[u] = ++ indexx;
	A[in[u]] = a[u];
	if(son[u] == -1) return ;
	dfs2(son[u], tp);
	for(int i = head[u]; i; i = edge[i].next) {
		int v = edge[i].v;
		if(v == son[u] || v == fa[u]) continue;
		dfs2(v, v);
	}
	out[u] = indexx;
}

Node *build(int l, int r) {
	Node *nd = ++ tail;
	if(l == r){
		nd->sum = A[l];
		nd->flag = 0;
		return nd;
	}
	int mid = (l + r) >> 1;
	nd->ls = build(l, mid);
	nd->rs = build(mid + 1, r);
	nd->sum = nd->ls->sum + nd->rs->sum;
	return nd;
}

void modify(int L, int R, int l, int r, int delta, Node *nd) {
	if(l >= L && R >= r) {
		nd->flag += delta;
		nd->sum += (LL) (r - l + 1) * delta;
		return ;
	}
	nd->pushdown(l, r);
	int mid = (l + r) >> 1;
	if(L <= mid)
		modify(L, R, l, mid, delta, nd->ls);
	if(R > mid)
		modify(L, R, mid + 1, r, delta, nd->rs);
	nd->update();
	return ;
}

LL ans(int L, int R, int l, int r, Node *nd) {
	if(l >= L && R >= r)
		return nd->sum;
	LL rt = 0;
	nd->pushdown(l, r);
	int mid = (l + r) >> 1;
	if(L <= mid)
		rt += ans(L, R, l, mid, nd->ls);
	if(R > mid)
		rt += ans(L, R, mid + 1, r, nd->rs);
	nd->update();
	return rt;
}

LL query(int u, int v) {
	LL sum = 0;
	int f1 = top[u], f2 = top[v];
	while(f1 != f2) {
		if(dep[f1] < dep[f2]) swap(f1, f2), swap(u, v);
		sum += ans(in[f1], in[u], 1, indexx, root);
		u = fa[f1];
		f1 = top[u];
	}
	if(dep[u] > dep[v]) swap(u, v);
	sum += ans(in[u], in[v], 1, indexx, root);
	return sum;
}

int main() {
	zero();
	scanf("%d %d", &n, &m);
	for(int i = 1; i <= n; i ++)
		scanf("%d", a + i);
	for(int i = 1; i < n; i ++) {
		int u, v;
		scanf("%d %d", &u, &v);
		add(u, v); add(v, u);
	}
	dfs1(1, -1, 0); dfs2(1, 1);
	root = build(1, indexx);
	for(int i = 1; i <= m; i ++) {
		int x;
		scanf("%d", &x);
		if(x == 1) {
			int u, delta;
			scanf("%d %d", &u, &delta);
			modify(in[u], in[u], 1, indexx, delta, root);
		}
		else if(x == 2) {
			int u, delta;
			scanf("%d %d", &u, &delta);
			modify(in[u], out[u], 1, indexx, delta, root);
		}
		else {
			int u;
			scanf("%d", &u);
			printf("%lld\n", query(1, u));
		}
	}
	return 0;
}