点击打开链接链接
Iahub likes trees very much. Recently he discovered an interesting tree named propagating tree. The tree consists of n nodes numbered from 1 to n, each node i having an initial value ai. The root of the tree is node 1.
This tree has a special property: when a value val is added to a value of node i, the value -val is added to values of all the children of node i. Note that when you add value -val to a child of node i, you also add -(-val) to all children of the child of node i and so on. Look an example explanation to understand better how it works.
This tree supports two types of queries:
- "1 x val" — val is added to the value of node x;
- "2 x" — print the current value of node x.
In order to help Iahub understand the tree better, you must answer m queries of the preceding type.
The first line contains two integers n and m (1 ≤ n, m ≤ 200000). The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1000). Each of the next n–1 lines contains two integers vi and ui (1 ≤ vi, ui ≤ n), meaning that there is an edge between nodes vi and ui.
Each of the next m lines contains a query in the format described above. It is guaranteed that the following constraints hold for all queries: 1 ≤ x ≤ n, 1 ≤ val ≤ 1000.
For each query of type two (print the value of node x) you must print the answer to the query on a separate line. The queries must be answered in the order given in the input.
5 5 1 2 1 1 2 1 2 1 3 2 4 2 5 1 2 3 1 1 2 2 1 2 2 2 4
3 3 0
The values of the nodes are [1, 2, 1, 1, 2] at the beginning.
Then value 3 is added to node 2. It propagates and value -3 is added to it's sons, node 4 and node 5. Then it cannot propagate any more. So the values of the nodes are [1, 5, 1, - 2, - 1].
Then value 2 is added to node 1. It propagates and value -2 is added to it's sons, node 2 and node 3. From node 2 it propagates again, adding value 2 to it's sons, node 4 and node 5. Node 3 has no sons, so it cannot propagate from there. The values of the nodes are [3, 3, - 1, 0, 1].
You can see all the definitions about the tree at the following link: http://en.wikipedia.org/wiki/Tree_(graph_theory)
题意:给出n个数和他们的父子关系 并进行以下操作:
1:将a点加b a的子节点-b a子节点的子节点+b 依次类推
2:求当前a点的值
开两个bit数组记录当前点的加减值
一遍bfs确定每个点的层数
代码:
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#define MAXN 222222
using namespace std;
struct Node{
int l,r,val,state;
}node[MAXN];
int bit[2][MAXN*2];
vector<int> fa[MAXN];
int cnt,n,m;
int lowbit(int x){
return x&(-x);
}
void add(int x,int val,int *bi){
while(x<MAXN*2){
bi[x]+=val;
x+=lowbit(x);
}
}
int getsum(int x,int *bi){
int ans=0;
while(x){
ans+=bi[x];
x-=lowbit(x);
}
return ans;
}
void dfs(int s,int pa,int state){
node[s].l=++cnt;node[s].state=state;
for(int i=0;i<fa[s].size();i++){
if(fa[s][i]==pa)
continue;
dfs(fa[s][i],s,!state);
}
node[s].r=++cnt;
}
int main(){
cnt=0;
int a,b;
memset(bit,0,sizeof(bit));
scanf("%d %d",&n,&m);
for(int i=1;i<=n;i++)
scanf("%d",&node[i].val);
for(int i=1;i<n;i++){
scanf("%d %d",&a,&b);
fa[a].push_back(b);
fa[b].push_back(a);
}
dfs(1,-1,0);
for(int i=1;i<=m;i++){
int op;
scanf("%d",&op);
if(op==1){
scanf("%d %d",&a,&b);
add(node[a].l,b,bit[node[a].state]);
add(node[a].r+1,-b,bit[node[a].state]);
}
else {
scanf("%d",&a);
printf("%d\n",node[a].val+getsum(node[a].l,bit[node[a].state])-getsum(node[a].l,bit[!node[a].state]));
}
}
return 0;
}