[BZOJ 4034][HAOI 2015] 树上操作 树链剖分+DFS序

题目传送门：【BZOJ 4034】

---

题目大意：有一棵点数为 N 的树，以点 1 为根，且树点有边权。然后有 M 个操作，分为三种：
操作 1 ：把某个节点 x 的点权增加 a 。
操作 2 ：把某个节点 x 为根的子树中所有点的点权都增加 a 。
操作 3 ：询问某个节点 x 到根的路径中所有点的点权和。

---

题目分析：
(经实验证明，本人的查错能力越发低下，又花了三个小时来做这道题)

由题，结合树链剖分型题目的性质，容易看出，这是一道树链剖分的裸题。
我们先对这棵树进行树链剖分，然后在这之上建立一棵线段树。
对于操作 1，直接找到 x 在线段树中的位置（单点修改）；
对于操作 2，根据 DFS 序的性质，可以发现，一个点及其子树的所有点在线段树中均为连续的一部分，所以直接根据点 x 的 DFS 序进行区间修改即可；
对于操作 3，由于 LCA( x , 1 ) == 1，所以先对 x 点从轻边边跳 father 边查询之后，再查询它到根 1 的权值，最后统计并求和即可。
所以这就是一道普通的树链剖分模板题。

下面附上代码：

[cpp] view plain copy

print ?

1. #include<cstdio>  
2. #include<algorithm>  
3. #define ls (nd<<1)  
4. #define rs (nd<<1|1)  
5. #define Root 1  
6. typedef long long LL;  
7. const int MX=200005;  
8. const int INF=1000005;                      //初始化懒标记时的值   
9.   
10. struct Edge{  
11.     int to,next;  
12. }edge[MX*2];  
13. int n,m,now=0,_index=0, L , R , pos ,line[MX],head[MX],seq[MX];  
14. int depth[MX],size[MX],fa[MX],son[MX],top[MX],in[MX],out[MX];  
15. struct SegTree{  
16.     LL sum,flag;  
17. }seg[MX*4];  
18.   
19. inline void adde(int u,int v){  
20.     edge[++now].to=v;  
21.     edge[now].next=head[u];  
22.     head[u]=now;  
23. }  
24. void dfs1(int u){  
25.     size[u]=1;  
26.     for (int i=head[u];i;i=edge[i].next){  
27.         int v=edge[i].to;  
28.         if (fa[u]==v) continue;  
29.         fa[v]=u;  
30.         depth[v]=depth[u]+1;  
31.         dfs1(v);  
32.         if (size[v]>size[son[u]]) son[u]=v;  
33.         size[u]+=size[v];  
34.     }  
35. }  
36. void dfs2(int u,int tp){  
37.     top[u]=tp;  
38.     seq[++_index]=u;  
39.     in[u]=_index;  
40.     if (son[u]) dfs2(son[u],tp);  
41.     for (int i=head[u];i;i=edge[i].next){  
42.         int v=edge[i].to;  
43.         if (fa[u]==v || son[u]==v) continue;  
44.         dfs2(v,v);  
45.     }  
46.     out[u]=_index;  
47. }  
48. /*————————–Dividing Line————————–*/  
49. void build(int nd,int lf,int rt){  
50.     if (lf==rt) seg[nd].sum=line[seq[lf]];  
51.     else {  
52.         int mid=(lf+rt)>>1;  
53.         build(ls,lf,mid);  
54.         build(rs,mid+1,rt);  
55.         seg[nd].sum=seg[ls].sum+seg[rs].sum;  
56.     }  
57. }  
58. void pushdown(int nd,int lf,int rt){  
59.     if (seg[nd].flag && lf!=rt){  
60.         int mid=(lf+rt)>>1;  
61.         seg[ls].flag+=seg[nd].flag;  
62.         seg[rs].flag+=seg[nd].flag;  
63.         seg[ls].sum+=seg[nd].flag*(mid-lf+1);  
64.         seg[rs].sum+=seg[nd].flag*(rt-mid);  
65.         seg[nd].flag=0;  
66.     }  
67. }  
68. void add(int nd,int lf,int rt,int val){//option. 1  
69.     pushdown(nd,lf,rt);  
70.     if (lf==rt){  
71.         seg[nd].sum+=val;  
72.         return;  
73.     }  
74.     int mid=(lf+rt)>>1;  
75.     if (pos<=mid) add(ls,lf,mid,val);  
76.     else add(rs,mid+1,rt,val);  
77.     seg[nd].sum=seg[ls].sum+seg[rs].sum;  
78. }  
79. void add_tree(int nd,int lf,int rt,int val){//option. 2  
80.     if (L>R) return;  
81.     pushdown(nd,lf,rt);  
82.     if (L<=lf && rt<=R){  
83.         seg[nd].sum+=(LL)val*(rt-lf+1);  
84.         seg[nd].flag+=(LL)val;  
85.         return;  
86.     }  
87.     int mid=(lf+rt)>>1;  
88.     if (L<=mid) add_tree(ls,lf,mid,val);  
89.     if (R>mid) add_tree(rs,mid+1,rt,val);  
90.     seg[nd].sum=seg[ls].sum+seg[rs].sum;  
91. }  
92. LL query(int nd,int lf,int rt){//option. 3  
93.     if (L>R) return 0;  
94.     pushdown(nd,lf,rt);  
95.     if (L<=lf && rt<=R)  
96.         return seg[nd].sum;  
97.       
98.     int mid=(lf+rt)>>1;  LL ans=0;  
99.     if (L<=mid) ans+=query(ls,lf,mid);  
100.     if (R>mid) ans+=query(rs,mid+1,rt);  
101.     return ans;  
102. }  
103. LL query(int u,int v){  
104.     LL ans=0;  
105.     while (top[u]!=top[v]){  
106.         if (depth[top[u]]<depth[top[v]]) std::swap(u,v);  
107.         L=in[top[u]],R=in[u];  
108.         ans+=query(Root,1,n);  
109.         u=fa[top[u]];  
110.     }  
111.     if (depth[u]<depth[v]) std::swap(u,v);  
112.     L=in[v],R=in[u];  
113.     ans+=query(Root,1,n);  
114.     return ans;  
115. }  
116. /*————————–Dividing Line————————–*/  
117. int main(){  
118.     int a,b,opt;  
119.     scanf(”%d%d”,&n,&m);  
120.     for (int i=1;i<=n;i++)  
121.         scanf(”%d”,&line[i]);  
122.     for (int i=1;i<n;i++){  
123.         scanf(”%d%d”,&a,&b);  
124.         adde(a,b),adde(b,a);  
125.     }  
126.     depth[1]=1,fa[1]=1;  
127.     dfs1(1);  
128.     dfs2(1,1);  
129.     build(Root,1,n);  
130.     for (int i=1;i<=m;i++){  
131.         scanf(”%d”,&opt);  
132.         if (opt==1){  
133.             scanf(”%d%d”,&a,&b);  
134.             pos=in[a];  add(Root,1,n,b);  
135.         }  
136.         if (opt==2){  
137.             scanf(”%d%d”,&a,&b);  
138.             L=in[a],R=out[a];  add_tree(Root,1,n,b);  
139.         }  
140.         if (opt==3){  
141.             scanf(”%d”,&a);  
142.             printf(”%lld\n”,query(a,1));  
143.         }  
144.     }  
145.     return 0;  
146. }