树链剖分入门-Hdu3966 Aragorn's Story

AC通道：http://acm.hdu.edu.cn/showproblem.php?pid=3966

[题目大意]

　　一棵树上每个点有权值，每次支持三种操作：给[a,b]路径上的所有节点的权值加上k，给[a,b]路径上的所有节点的权值减去k，以及询问a的权值．

[分析]

　　这是一道树链剖分模板题．

　　树链剖分，就是将树化成了许多链，将这些链用数据结构保存起来，再去维护这个数据结构．

　　假设给的树就是一条链，这道题当然很好办：直接将链用线段树存了，因为[a,b]的路径在线段树上也是连续的一段，那么修改一段就是log(n)的，询问节点也可以log(n)完成．

　　但是给的是一棵树，树上两点间的路径虽然也是唯一确定的，但是在线段树上就不一定是连续的一段了．　　

　　于是乎，就需要一种将每条树上路径分成若干个连续段的算法．

　　这就是树链剖分了．

　　

　　首先定义一下重儿子的概念：v是u的重儿子，当且仅当size(v)>=size(v')对于任意u的儿子v'成立．就是u的儿子中所在子树最大的儿子．

　　树链剖分将树分成重链和轻边，重链指的是每个节点与其重儿子相连，其重儿子再与其重孙子相连得到的链．轻边就是连接重链的边．

　　[我这儿没图....要图找别人：http://blog.sina.com.cn/s/blog_7a1746820100wp67.html　这个图其实也长得不怎么好看]

　　通过这样一个划分，就有了优美的性质：任意两点间的路径上最多有log(n)条重链．

　　然后就可以将重链上的点连续地存进线段树中，每次将路径划分成若干个重链的部分来处理就可以了．

　　这样下来每条路径处理就是log(n)*log(n)的．

　　具体步骤：

　　　　首先一遍dfs．处理出一些东西：每个节点子树的大小->每个点的重儿子，每个点的深度[这个在划分路径的时候有用]，每个节点的父节点．

　　　　然后再一遍dfs．给每个点标号，注意将重链的编号连续，同时记录每个点所在重链的顶端节点[这个怎么操作可以具体看代码]

　　　　然后建线段树：跟往常一样的建立方法．

　　　　

　　　　询问：在线段树上询问，记得下传标记就好．

　　　　修改：思考怎么划分，如果询问的两点，假设是x,y．

　　　　当x,y处于同一条重链时：直接用线段树的区间修改，当不是同一条重链时，就需要将他们移动到同一条重链．

　　　　首先判断x,y所在重链，谁的上端距离根更远，假设是x，那么将x调至其所在重链的上端的父亲节点[这样就移动到了另一条重链上]，同时还要将x到重链上端的这一部分在线段树中加tag．

　　　　依次这样操作，就可以等到x,y在同一条重链上的时候了．[具体也可以看代码]

　　希望通过这道题，大家也就能大概理解树链剖分的思想所在了...

　　献上代码：

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

using namespace std;

inline int in(){
    int x=,f=;char ch=getchar();
    while((ch>'' || ch<'') && ch!='-') ch=getchar();
    if(ch=='-') f=-,ch=getchar();
    while(ch>='' && ch<='') x=x*+ch-'',ch=getchar();
    return x*f;
}

const int maxn=;

int n,m,q;
int cnt;
int a[maxn],id[maxn],Idex,rk[maxn];
int depth[maxn],sz[maxn],fa[maxn];
int top[maxn],son[maxn],head[maxn];
char ord[];

struct Spot{
    int data,next;
}spot[maxn<<];

#define now spot[pt].data
#define then spot[pt].next

struct Node{
    int dt,tg;
}s[maxn<<];

inline void add(int u,int v){
    spot[cnt].data=v;spot[cnt].next=head[u];head[u]=cnt++;
    spot[cnt].data=u;spot[cnt].next=head[v];head[v]=cnt++;
}

void dfs1(int x,int f){
    sz[x]=,fa[x]=f;
    for(int pt=head[x];pt!=-;pt=then)
        if(now!=f){
            depth[now]=depth[x]+;
            dfs1(now,x);
            sz[x]+=sz[now];
            if(son[x]< || sz[now]>sz[son[x]])
                son[x]=now;
        }
}

void dfs2(int x,int tp){
    top[x]=tp,id[x]=++Idex,rk[id[x]]=x;
    if(son[x]<) return;
    dfs2(son[x],tp);
    for(int pt=head[x];pt!=-;pt=then)
        if(now!=fa[x] && now!=son[x])
            dfs2(now,now);
}

void build(int l,int r,int rt){
    s[rt].dt=s[rt].tg=;
    if(l==r){
        s[rt].dt=a[rk[l]];return;
    }
    int mid=(l+r)>>;
    build(l,mid,rt<<);
    build(mid+,r,rt<<|);
}

inline void push_down(int x){
    if(s[x].tg){
        s[x<<].tg+=s[x].tg,s[x<<].dt+=s[x].tg;
        s[x<<|].tg+=s[x].tg,s[x<<|].dt+=s[x].tg;
        s[x].tg=;
    }
}

void add_tag(int l,int r,int x,int y,int rt,int val){
    if(l==x && r==y){
        s[rt].dt+=val,s[rt].tg+=val;
        return;
    }
    int mid=(l+r)>>;
    if(y<=mid) add_tag(l,mid,x,y,rt<<,val);
    else if(x>mid) add_tag(mid+,r,x,y,rt<<|,val);
    else add_tag(l,mid,x,mid,rt<<,val),add_tag(mid+,r,mid+,y,rt<<|,val);
}

int query(int l,int r,int rt,int k){
    if(l==r)
        return s[rt].dt;
    push_down(rt);
    int mid=(l+r)>>;
    if(k<=mid) return query(l,mid,rt<<,k);
    else return query(mid+,r,rt<<|,k);
}

void modify(int x,int y,int val){
    while(top[x]!=top[y]){
        if(depth[top[x]]<depth[top[y]]) swap(x,y);
        add_tag(,n,id[top[x]],id[x],,val);
        x=fa[top[x]];
    }
    if(id[x]>id[y]) swap(x,y);
    add_tag(,n,id[x],id[y],,val);
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("3966.in","r",stdin);
    freopen("3966.out","w",stdout);
#endif

    int u,v,x;

    while(~scanf("%d%d%d",&n,&m,&q)){
        Idex=cnt=;
        for(int i=;i<=n;i++)
            a[i]=in(),head[i]=son[i]=-;
        for(int i=;i<n;i++)
            u=in(),v=in(),add(u,v); 

        dfs1(,);
        dfs2(,);
        build(,n,);

        while(q--){
            scanf("%s",ord);
            if(ord[]=='Q'){
                x=in();
                printf("%d\n",query(,n,,id[x]));
            }
            else{
                u=in(),v=in(),x=in();
                if(ord[]=='D') x=-x;
                modify(u,v,x);
            }
        }
    }
    return ;
}