HDU 3966 (树链剖分+线段树）

Problem Aragorn's Story （HDU 3966）

题目大意

　　给定一颗树，有点权。

　　要求支持两种操作，将一条路径上的所有点权值增加或减少ai，询问某点的权值。

解题分析

　　树链剖分模板题。

　　实质上树链剖分进行了点对点的一次映射，保证了重链上的点在线段树上的位置是连续的。

　　树链剖分的两个性质(转):

　　　　性质1：如果(v,u)为轻边，则siz[u] * 2 < siz[v]；

　　　　性质2：从根到某一点的路径上轻链、重链的个数都不大于logn。

　　保证了一个区间的时间复杂度是log2(n)。

　　要分清3种标号含义（易混） ：树中节点标号，树中节点对应线段树中位置标号，线段树中区间标号。

　　树链剖分相关数组意义 ：

　　　　size[i] ：以i为根的子树的大小

　　　　fa[i] ：i节点的父亲

　　　　dep[i] ：i节点的深度

　　　　son[i] ：i节点的重儿子（所有儿子中size最大的）

　　　　w[i] ：i节点在线段树中对应的位置

　　　　top[i] ：i节点所在重链的顶端节点，若为轻链，则为自身。

　　　　rank[i] ：线段树中所对应树中节点。

参考程序

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <cmath>

 #define V 50008
 #define E 100008
 #define lson l,m,rt<<1
 #define rson m+1,r,rt<<1|1

 int n,m,Q;
 int a[V],size[V],dep[V],fa[V],top[V],w[V],son[V],rank[V];
 int sum[V << ],lazy[V << ];

 struct line{
     int u,v,nt;
 }eg[E];
 int lt[V],summ,cnt;

 void adt(int u,int v){
     eg[++summ].u=u; eg[summ].v=v; eg[summ].nt=lt[u]; lt[u]=summ;
 }

 void add(int u,int v){
     adt(u,v); adt(v,u);
 }

 void dfs1(int u){
     size[u]=; son[u]=;
     for (int i=lt[u];i;i=eg[i].nt){
         int v=eg[i].v;
         if (v!=fa[u]){
             fa[v]=u;
             dep[v]=dep[u]+;
             dfs1(v);
             size[u]+=size[v];
             if (size[v]>size[son[u]]) son[u]=v;
         }
     }
 }

 void dfs2(int u,int tp,int x){
     top[u]=tp; w[u]=++cnt; rank[cnt]=u;
     if (son[u]) dfs2(son[u],tp,);
     for (int i=lt[u];i;i=eg[i].nt){
         int v=eg[i].v;
         if (v==son[u] || v==fa[u]) continue;
         dfs2(v,v,);
     }
 }

 void init(){
     memset(lt,,sizeof(lt));
     summ=; cnt=;
     for (int i=;i<=n;i++) scanf("%d",&a[i]);
     for (int i=;i<=m;i++){
         int u,v;
         scanf("%d %d",&u,&v);
         add(u,v);
     }
     dep[]=; fa[]=;
     dfs1();
     dfs2(,,);
 }

 void pushup(int rt){
     sum[rt]=sum[rt<<]+sum[rt<<|];
 }

 void pushdown(int rt,int m){
     if (lazy[rt]){
         lazy[rt<<]+=lazy[rt];
         lazy[rt<<|]+=lazy[rt];
         sum[rt<<]+=lazy[rt]*(m-m / );
         sum[rt<<|]+=lazy[rt]*(m / );
         lazy[rt]=;
     }
 }

 void build(int l,int r,int rt){
     lazy[rt]=;
     if (l==r){
         sum[rt]=a[rank[l]];
         return;
     }
     int m=(l+r)/;
     build(lson);
     build(rson);
     pushup(rt);
 }

 void update(int L,int R,int val,int l,int r,int rt){
     if (L<=l && r<=R){
         sum[rt]+=val*(r-l+);
         lazy[rt]+=val;
         return;
     }
     pushdown(rt,r-l+);
     int m=(l+r)>>;
     if (L<=m) update(L,R,val,lson);
     if (m< R) update(L,R,val,rson);
     pushup(rt);
 }

 int query(int x,int l,int r,int rt){
     if (l==r){
         return sum[rt];
     }
     pushdown(rt,r-l+);
     int m=(l+r)>>;
     if (x<=m) return query(x,lson);
     if (m< x) return query(x,rson);
 }

 void change(int x,int y,int val){
     while (top[x]!=top[y]){
         if (dep[top[x]]<dep[top[y]]) std::swap(x,y);
         update(w[top[x]],w[x],val,,n,);
         x=fa[top[x]];
     }
     if (dep[x]>dep[y]) std::swap(x,y);
     update(w[x],w[y],val,,n,);
 }

 int main(){
     while (~scanf("%d %d %d",&n,&m,&Q)){
         init();
         build(,n,);
         while (Q--){
             char s[];
             int x,y,z;
             scanf("%s",s);
             if (s[]=='I'){
                 scanf("%d %d %d",&x,&y,&z);
                 change(x,y,z);
             }
             if (s[]=='D'){
                 scanf("%d %d %d",&x,&y,&z);
                 change(x,y,-z);
             }
             if (s[]=='Q'){
                 scanf("%d",&x);
                 printf("%d\n",query(w[x],,n,));
             }
         }
     }
 }