[bzoj4034][HAOI2015]树上操作 dfs序+树状数组

4034: [HAOI2015]树上操作

Time Limit: 10 Sec   Memory Limit: 256 MB
[ 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 。

Source

竟然进第一页了，这说明了树状数组的无比优越性，但是加个读入优化速度怎么就快了那么多呢

#include<cstdio>
typedef long long ll;
const int N = 1000000 + 5;
ll c[N][3],dep[N];
int last[N],cnt,in[N],out[N],scnt,n,m,T,a[N];
struct Edge{ int to, next; }e[N*4];
void modify( int x, ll val, int key ){ for( int i = x; i <= scnt; i += i&(-i) ) c[i][key] += val; }
ll query( int x, int key ){
	ll res = 0; for( int i = x; i; i -= i&(-i) ) res += c[i][key];
	return res;
}
void insert( int u, int v ){
	e[++cnt].to = v; e[cnt].next = last[u]; last[u] = cnt;
	e[++cnt].to = u; e[cnt].next = last[v]; last[v] = cnt;
}
void dfs( int x, int fa ){
	in[x] = ++scnt;
	for( int i = last[x]; i; i = e[i].next )
		if( e[i].to != fa ){
			dep[e[i].to] = dep[x] + 1; dfs(e[i].to,x);
		}
	out[x] = ++scnt;
}
int main(){
	scanf("%d%d", &n, &m);
	for( int i = 1; i <= n; i++ ) scanf("%d", &a[i]);
	for( int i = 1,u,v; i < n; i++ ){
		scanf("%d%d", &u, &v); insert( u, v );
	}
	dfs(1,0);
	for( int i = 1; i <= n; i++ ) modify( in[i], a[i], 0 ), modify( out[i], -a[i], 0 );
	for( int i = 1; i <= m; i++ ){
		scanf("%d", &T); int k,x; 
		if( T == 1 ){
			scanf("%d%d", &k, &x);
			modify( in[k], x, 0 ); modify( out[k], -x, 0 );
		} if( T == 2 ){
			scanf("%d%d", &k, &x);
			modify( in[k], x, 1 ); modify( out[k], -x, 1 );
			modify( in[k], dep[k]*(ll)x, 2 ); modify( out[k], -dep[k]*(ll)x, 2 );
		} if( T == 3 ){
			scanf("%d", &x);
			printf("%lld\n",query(in[x],1)*(dep[x]+1)+query(in[x],0)-query(in[x],2));
		}
	}
	return 0;
}