树链剖分

　　首先了解一下基本概念：

　　重儿子：siz[u]为v的子节点中siz值最大的，那么u就是v的重儿子。
      轻儿子：v的其它子节点。
      重边：点v与其重儿子的连边。
      轻边：点v与其轻儿子的连边。
      重链：由重边连成的路径。
      轻链：轻边。

      剖分后的树有如下性质：
      性质1：如果(v,u)为轻边，则siz[u] * 2 < siz[v]；
      性质2：从根到某一点的路径上轻链、重链的个数都不大于logN。

　　树链剖分，如其字面意思，就是将一棵树按照轻重边剖分为多条链，使得每个节点都属于一条重链，然后按照某种顺序将链依次连接成一维结构，再通过线段树、树状数组、Splay等维护这条长链上的每一条链。

　　由于重链的个数是O(logN)的，而每条链上的操作也是O(logN)的，故一次树上路径的操作的花费为O(log²N)。

　　模板：

　　模板题--hdu3966

　　题目输入输出要求：N个点，M（M=N-1）条边，K个操作

　　　　　　　　　　　N个点的值

　　　　　　　　　　　M行 （u, v）边

　　　　　　　　　　　K个操作，I （或D）a b c：a~b路径上的点值加（或减）c，Q a：a节点的值

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<set>
#include<queue>
#include<vector>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;

const int N = 50010, M = N * 2;
const int inf = 0x3f3f3f3f;
/*=============================================================*/
/** 建树 */
struct EG {
    int u, v;
    EG(){}
    EG(int u, int v) : u(u), v(v) {}
} eg[M];
int first[N], Next[M];
int tot;
void init()
{
    tot = 0;
    memset(first, -1, sizeof(first));
}
void add_edge(int u, int v)
{
    eg[++tot] = EG(u, v);
    Next[tot] = first[u], first[u] = tot;
    eg[++tot] = EG(v, u);
    Next[tot] = first[v], first[v] = tot;
}

/*=============================================================*/

int fa[N], son[N], dep[N], dfn[N], top[N], sz[N], Rank[N], d[N];
int tim;
/** 以DFS序遍历整棵树并获得如下信息：
    sz[u] : 以u为根节点的子树的结点个数，是判断重儿子的依据
    son[u]: 重儿子
    dep[u]: u节点的深度
    fa[u]: u节点的父节点
*/
void DFS1(int u)
{
    sz[u] = 1;
    son[u] = -1;
    for(int i=first[u]; i!=-1; i=Next[i])
    {
        EG &e = eg[i];
        if(e.v == fa[u]) continue;
        dep[e.v] = dep[u] + 1;
        fa[e.v] = u;
        DFS1(e.v);
        sz[u] += sz[e.v];
        if(son[u]==-1 || sz[son[u]] < sz[e.v])
            son[u] = e.v;
    }
}

/**
    将上面产生的重链串起来，生成Rank[]和dfn[]数组。
    top[u]: u节点所在链的顶端节点
    dfn[u]: u节点的DFS时间戳，各个重链是按照时间戳的先后形成的，也就是说，线段树、树状数组维护的数列是由时间戳从小到大一次形成的
    Rank[t]: 时间戳为t的节点
*/
void DFS2(int u, int tp)
{
    top[u] = tp;
    dfn[u] = ++tim;
    Rank[tim] = u;
    if(son[u] == -1) return;
    DFS2(son[u], tp);
    for(int i=first[u]; i!=-1; i=Next[i])
    {
        EG &e = eg[i];
        if(e.v != fa[u] && e.v != son[u])
            DFS2(e.v, e.v);
    }
}

/** 线段树改段求点模板 */
int mak[N<<2];
void build(int l, int r, int rt)
{
    mak[rt] = 0;
    if(l == r) {
        mak[rt] += d[Rank[l]];
        return;
    }
    int m = l + r >> 1;
    build(l, m, rt<<1);
    build(m+1, r, rt<<1|1);
}

void update(int L, int R, int a, int l, int r, int rt)
{
    if(L <= l && R >= r) {
        mak[rt] += a;
        return;
    }
    int m = l + r >> 1;
    if(L <= m) update(L, R, a, l, m, rt<<1);
    if(R > m)  update(L, R, a, m+1, r, rt<<1|1);
}

void query(int pos, int &a, int l, int r, int rt)
{
    a += mak[rt];
    if(l == r)
        return;
    int m = l + r >> 1;
    if(pos <= m) query(pos, a, l, m, rt<<1);
    else query(pos, a, m+1, r, rt<<1|1);
}

/*==========================================================*/

/** 操作树结构上在u、v路径上的节点*/
void Update(int u, int v, int a, int n)
{
    while(top[u] != top[v]) //当u、v节点不在同一条链上
    {
        //避免分类讨论，让u代表所在链顶较低的点
        if(dep[top[u]] < dep[top[v]]) swap(u, v);
        //top[u]~u这段路径在同一条重链上，其时间戳连续，更新之
        update(dfn[top[u]], dfn[u], a, 1, n, 1);
        
        //向上挑至链顶的父节点
        /*为什么是向上跳呢？
            因为v点所在链的顶端高于（或就是）u点所在链的顶端，无论哪种情况，v点所在链的顶端点的父节点在u~v链上*/
        u = fa[top[u]];
    }
    //此时，u、v在同一条链上，甚至u=v
    //重链上的节点，随着向子孙延伸，时间戳是递增的，即数列序是递增的
    if(dep[u] > dep[v]) swap(u, v);
    update(dfn[u], dfn[v], a, 1, n, 1);
}

/*==========================================================*/

int main()
{
    int n, m, k;
    while(scanf("%d %d %d", &n, &m, &k) == 3)
    {
        for(int i=1; i<=n; i++) scanf("%d", d+i);
        int a, b, c;
        init();
        for(int i=1; i<=m; i++)
            scanf("%d %d", &a, &b), add_edge(a,b);
        char s[3];
        dep[1] = 0;
        fa[1] = 1;
        tim = 0;
        DFS1(1);
        DFS2(1, 1);
        build(1, n, 1);
        while(k--)
        {
            scanf("%s", s);
            if(s[0] == 'Q') {
                scanf("%d", &a);
                b = 0;
                query(dfn[a], b, 1, n, 1);
                printf("%d
", b);
            }
            else {
                scanf("%d %d %d", &a, &b, &c);
                Update(a, b, s[0]=='I' ? c : -c, n);
            }
        }
    }
    return 0;
}

 小结练习