樹鏈剖分的原理

對於陣列這樣的線性結構，要在其上實現區間查詢（和與最值）、區間修改甚至是區間增刪都是有辦法的。例如Sparse Table演算法、樹狀陣列、線段樹以及伸展樹等。而樹是一種非線性結構，為了高效的實現在樹上的路徑查詢、路徑修改操作，基本做法是將樹按照某種方式剖成若干條鏈，再將這些鏈按照順序組成陣列，最後在陣列上採用線段樹等手段實現操作。
考慮如下一棵樹：

可以把它剖成6條鏈，分別是ACHLN、G、IM、BFK、E和DJ，因此對應的新陣列是

輕重邊剖分

輕重邊剖分（Heavy-light Decomposition）是樹鏈剖分常用的一種方法，上面的例子就是一個HLD的例子。HLD可以用來解決一大類問題：在樹的結構形態不發生變化的前提下，實現路徑操作和子樹操作（修改、查詢和及最值）

。
重兒子：某個節點的子節點，其子樹節點數量最大，則該子節點為該節點的重兒子。其餘為輕兒子。在上例中，C是A的重兒子，H是C的重兒子，F是B的重兒子。
重邊：父節點和重兒子之間的邊稱為重邊。在上例中，AC、CH、BF都是重邊。對應的，父節點和輕兒子的邊就稱為輕邊。
重鏈：全部由重邊構成的路徑稱為重鏈，又稱為重路徑。在上例中，ACHLN、G、IM、BFK、E和DJ就是重鏈。
N個節點的樹的任意一條路徑上，最多隻有logN條重鏈。每一條重鏈就是對應陣列的一個連續的部分，因此其上的操作最多為logN。因此每次樹上操作的時間為log2N。
考慮每一次路徑操作，我們需要知道路徑到底是由哪些重鏈組成的以及這些重鏈在陣列中對應的部分。路徑上的重鏈資訊顯然是可以求出的，但是不必專門求出，在操作中不停更新重鏈即可。為了更新重鏈資訊，對於每個節點還需記錄深度資訊d

epth以及每個節點所在重鏈的最頂層節點top。深度資訊比較容易理解。top資訊實際上就是每條鏈的第一個節點，例如在上例中H的top就是A，L的top也是A，而K的top則是B。
有了depth和top資訊，即可進行路徑操作。考慮KM之間的路徑操作。因為K和M的top不同，所以可以肯定KM不是一條重鏈。又因為M的top深度更深，所以可以肯定M及其top之間的重鏈全部都在路徑上，可以進行一次區間操作；該次操作完成以後就跳到節點C，因為節點C是M的top的父節點。再次考慮KC，因為K的top深度更深，所以BK全部在路徑上，進行一次區間操作；然後跳到A。A、C的top相同，說明AC是最後一段區間，對其進行操作即可。
因為輕重邊的區別完全取決於子樹的節點數量，每個節點設定一個s

ize域，在一次深搜中就能確定size的值，同時可以確定每個節點的重兒子，以及每個節點的depth資訊與父節點。確定重兒子以後，再一次深搜就可以確定重鏈的順序以及每個節點的top。此次深搜的順序即轉化後的陣列的索引序號，然後對該陣列建樹狀陣列或者線段樹並進行操作即可。因此，整個解法複雜度為O(N+Qlog2N)。其中Q為操作的總數量。

實現

hdu3966是一個典型的樹鏈剖分題目，樹的形態維持不變，路徑更新、單點查詢，剖分完以後使用帶延遲的線段樹即可。

//#pragma comment(linker, "/STACK:1024000000,1024000000") 
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

#define SIZE 50010

struct edge_t{
    int node;//另一個節點的編號
    int next;//下一條邊的地址，實際地址為Edge+next
}Edge[SIZE<<1];
int ECnt = 0;
int Vertex[SIZE];//鄰接表表示所有的邊

//a、b之間建立兩條無向邊
void mkEdge(int a,int b){
    Edge[ECnt].node = b;
    Edge[ECnt].next = Vertex[a];
    Vertex[a] = ECnt ++;

    Edge[ECnt].node = a;
    Edge[ECnt].next = Vertex[b];
    Vertex[b] = ECnt ++;
}

struct node_t{
    int parent;   //父節點
    int heavy_son;//重邊的子節點
    int depth;     //深度
    int size;     //size域
    int top;      //本節點所在的重鏈的最頂層節點
    int nid;      //在dfs重鏈時重新對節點編號，確保同一條鏈上的節點相鄰
    int weight;   //權值,本題中即所求的數量
}Node[SIZE];
int TIdx = 0;
int NewIdx[SIZE];//新編號到原樹節點的對映
int N,M,P;

//dfs找出所有重邊，t為節點，parent為其父節點，depth為深度
//該dfs實際上確立了樹的結構
void dfsHeavyEdge(int t,int parent,int depth){
    Node[t].depth = depth;
    Node[t].parent = parent;
    Node[t].size = 1;
    //對t的所有子節點
    for(int next=Vertex[t];next;next=Edge[next].next){
        int u = Edge[next].node;
        if ( u == parent ) continue;
        dfsHeavyEdge(u,t,depth+1);
        Node[t].size += Node[u].size;
        //判斷重邊
        if ( Node[u].size > Node[Node[t].heavy_son].size )
            Node[t].heavy_son = u;
    }
}

//dfs找出所有重鏈,t為節點，top為當前節點所在重鏈的最頂層節點
//重鏈實際上是以其頂層節點為標識儲存的，任意節點都能夠直接得出其所在重鏈的頂層節點
void dfsHeavyPath(int t,int top){
    Node[t].top = top;
    Node[t].nid = TIdx++;
    NewIdx[Node[t].nid] = t;

    //t沒有重兒子，實際上就是葉節點
    if ( 0 == Node[t].heavy_son ) return;
    dfsHeavyPath(Node[t].heavy_son,top);

    //對t的所有節點
    for(int next=Vertex[t];next;next=Edge[next].next){
        int u = Edge[next].node;
        if ( u == Node[t].parent 
            || u == Node[t].heavy_son ) continue;

        dfsHeavyPath(u,u);
    }
}

//帶延遲的求區間和的線段樹
struct stnode_t{
    int peak;
    int delay;
}ST[SIZE<<2];

inline int lson(int t){return t<<1;}
inline int rson(int t){return (t<<1)|1;}

void _pushUp(int t){ST[t].peak=ST[lson(t)].peak+ST[rson(t)].peak;}
void _pushDown(int t){
    if ( 0 == ST[t].delay ) return;

    ST[lson(t)].delay += ST[t].delay;
    ST[lson(t)].peak += ST[t].delay;
    ST[rson(t)].delay += ST[t].delay;
    ST[rson(t)].peak += ST[t].delay;
    ST[t].delay = 0;
}

//建樹，遞迴建立節點
void build(int t,int s,int e){
    ST[t].delay = 0;

    if ( s == e ){
        ST[t].peak = Node[NewIdx[s]].weight;
        return;
    }
    int mid = ( s + e ) >> 1;
    build(lson(t),s,mid);
    build(rson(t),mid+1,e);
    _pushUp(t);
}
//[a,b]區間增加delta
void modify(int t,int s,int e,int a,int b,int delta){
    if ( a <= s && e <= b ){
        ST[t].delay += delta;
        ST[t].peak += delta;
        return;
    }

    _pushDown(t);
    int mid = ( s + e ) >> 1;
    if ( a <= mid ) modify(lson(t),s,mid,a,b,delta);
    if ( mid < b ) modify(rson(t),mid+1,e,a,b,delta);
    _pushUp(t);
}
//單點查詢
int query(int t,int s,int e,int idx){
    if ( s == e ) return ST[t].peak;
    _pushDown(t);
    int mid = ( s + e ) >> 1;
    int ret = ( idx <= mid ) 
        ? query(lson(t),s,mid,idx)
        : query(rson(t),mid+1,e,idx);
    _pushUp(t);
    return ret;
}

//關鍵操作，將原樹上(x,y)路徑的所有節點權值增加val
void change(int x,int y,int val){
    //當x,y不處於同一條重鏈
    while( Node[x].top != Node[y].top ){
        //令x所處的重鏈總是更深
        if ( Node[Node[x].top].depth < Node[Node[y].top].depth )
            swap(x,y);
        //將x所在的鏈的鏈頂到x的區間進行修改
        modify(1,1,N,Node[Node[x].top].nid,Node[x].nid,val);
        //將x修改為原鏈頂的父親，實質上就是跳到了另外一條鏈
        x = Node[Node[x].top].parent;
    }
    //到此處時，x、y處於同一條鏈，令x總是更淺，此舉是為了確定左右區間
    if ( Node[x].depth > Node[y].depth ) swap(x,y);
    //將x、y之間的路徑更新
    modify(1,1,N,Node[x].nid,Node[y].nid,val);
}
inline void init(){
    ECnt = TIdx = 1;
    fill(Vertex,Vertex+N+1,0);
    for(int i=0;i<=N;++i)Node[i].heavy_son = 0;
}
bool read(){
    if ( EOF == scanf("%d%d%d",&N,&M,&P) )
        return false;

    init();
    for(int i=1;i<=N;++i)scanf("%d",&Node[i].weight);
    for(int i=0;i<M;++i){
        int a,b;
        scanf("%d%d",&a,&b);
        mkEdge(a,b);
    }
    //以第1個節點為根建樹
    dfsHeavyEdge(1,0,0);
    //從根節點開始遞迴建重鏈
    dfsHeavyPath(1,1);
    //以ST[1]為根節點區間[1,N]建線段樹
    build(1,1,N);
    return true;
}
char Cmd[5];
int main(){
    while( read() ){
        while(P--){
            scanf("%s",Cmd);
            if ( 'Q' == *Cmd ){
                int x;
                scanf("%d",&x);
                printf("%d\n",query(1,1,N,Node[x].nid));
            }else{
                int x,y,v;
                scanf("%d%d%d",&x,&y,&v);
                if ( 'D' == *Cmd ) v = -v;
                change(x,y,v);
            }
        }
    }
    return 0;
}