树链剖分简(单)介(绍)

　　树链剖分可以算是一种数据结构(一大堆数组，按照这个意思，主席树就是一大堆线段树)。将一棵树分割成许多条连续的树链，方便完成一下问题:

1. 单点修改(dfs序可以完成)
2. 求LCA(各种乱搞也可以)
3. 树链修改(修改任意树上两点之间的唯一路径)
4. 树链查询
5. （各种操作）

 　  前两个内容可以用其他方式解决，但是下面两种操作倍增、st表，dfs序就很难解决(解决当然可以解决，只是耗时长点而已)。下面开始步入正题。

　　树链剖分的主要目的是分割树，使它成一条链，然后交给其他数据结构(如线段树,Splay)来进行维护。常见的分割树的方法(轻重链剖分)就是分重儿子和轻儿子。对于一个根节点，它的节点最多的子树的根节点(也就是它的某个子节点，如果有几个数量相同，那么随意)，其它都是轻儿子。根节点和重儿子连成的边叫重边，根节点和轻儿子连成的边叫轻边。如下图:

　　由此，由于这种剖分方式便有了一些性质:

一条根节点到叶节点的路径上，轻边的条数不超过log2n条	因为轻儿子的所在子树的节点总数不超过父节点的size的一半(不然它就成重儿子了)，所以最多log2n条轻边后，节点总数就变为1了
一条根节点到叶节点的路径上，重链的条数不超过log2n条
有2log22n条重链精确覆盖树上任意两点之间的路径

　　重边相连的点构成了重链(特殊的，单独的一个点，比如说4、9、11号节点也可以看成是重链)，然后为了能够让其它数据结构能够更好地处理这棵树，就为这棵树重新编号，让一条重链上的所有点的编号是连续的(这样才能快速查询，修改)。于是改变了dfs的顺序，先访问重儿子，再访问其它儿子，于是由上图得到了下面这个序列:

　　于是单点修改的时候，直接交给线段树处理掉就行了。下面来解决求LCA的问题，比如说节点8和节点4。首先将树链开始深度更深的一个节点跳到树链的开头，再往上跳到父节点(新的一个树链)，直到两个点到了同一条重链上，返回深度更小的那个点，就是LCA。

 　　

　　代码还挺短的:

int lca(int a, int b){
    while(top[a] != top[b]){
        int& d = (dep[top[a]] > dep[top[b]]) ? (a) : (b);
        d = fa[top[d]];
    }
    return (dep[a] < dep[b]) ? (a) : (b);
}

　　对于链上修改，链上查询的思路差不多，只不过在从一个点跳到另一个点上，要用线段树得到这一段路径的值，由于这条路径上的重链数量不超过$log_2 n$，所以时间复杂度为$O(log ^2 n)$。(还算能够接受)

　　根据以上各种操作，得出了以下需要预处理出的数组:

size[i]:节点i的大小(以节点i为根的子树的节点总数)

zson[i]:节点i的重儿子(如果没有，就用个特值表示好了，以便区分)

dep[i]:节点i的深度

fa[i]:节点i的父节点

top[i]:节点i所在的重链的dep最小的一个节点

visitID[i]:节点i的访问编号

exitID[i]:节点i的离开时编号(如果没有对整棵子树进行操作的操作就可以不用)

visit[i]:第i个访问的节点是(建立线段树的时候使用)

　　前四个可以第一次dfs搞定:

void dfs1(int node, int last) {
    dep[node] = dep[last] + 1;
    size[node] = 1;
    fa[node] = last;
    int maxs = 0, maxid = 0;
    for(int i = m_begin(g, node); i != 0; i = g[i].next) {
        int& e = g[i].end;
        if(e == last)    continue;
        dfs1(e, node);
        size[node] += size[e];
        if(size[e] > maxs)    maxs = size[e], maxid = e;
    }
    zson[node] = maxid;
}

　　后四个不着急，不忙一次搞完，第二次dfs，把剩下的这四个数组的值都get到。

void dfs2(int node, int last, boolean iszson) {
    top[node] = (iszson) ? (top[last]) : (node);
    visitID[node] = ++cnt;
    visit[cnt] = node;
    if(zson[node] != 0)    dfs2(zson[node], node, true);
    for(int i = m_begin(g, node); i != 0; i = g[i].next) {
        int& e = g[i].end;
        if(e == last || e == zson[node])    continue;
        dfs2(e, node, false);
    }
    exitID[node] = cnt;
}

bzoj1036的完整代码(可能和上面有点出入):

/**
 * bzoj
 * Problem#1036
 * Accepted
 * Time:2464ms
 * Memory:6060k
 */
#include<iostream>
#include<fstream>
#include<sstream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#include<cctype>
#include<cmath>
#include<algorithm>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<vector>
#ifndef WIN32
#define AUTO "%lld"
#else
#define AUTO "%I64d"
#endif
using namespace std;
typedef bool boolean;
#define inf 0xfffffff
#define smin(a, b)    (a) = min((a), (b))
#define smax(a, b)    (a) = max((a), (b))
template<typename T>
inline void readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-' && x != -1);
    if(x == -1)    return;
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u << 3) + (u << 1) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
}

///map template starts
typedef class Edge{
    public:
        int end;
        int next;
        Edge(const int end = 0, const int next = 0):end(end), next(next){}
}Edge;
typedef class MapManager{
    public:
        int ce;
        int *h;
        Edge *edge;
        MapManager(){}
        MapManager(int points, int limit):ce(0){
            h = new int[(const int)(points + 1)];
            edge = new Edge[(const int)(limit + 1)];
            memset(h, 0, sizeof(int) * (points + 1));
        }
        inline void addEdge(int from, int end){
            edge[++ce] = Edge(end, h[from]);
            h[from] = ce;
        }
        inline void addDoubleEdge(int from, int end){
            addEdge(from, end);
            addEdge(end, from);
        }
        Edge& operator [](int pos) {
            return edge[pos];
        }
}MapManager;
#define m_begin(g, i) (g).h[(i)]
///map template ends

typedef class SegTreeNode {
    public:
        int maxv;
        long long sum;
        SegTreeNode* left, *right;
        
        SegTreeNode():maxv(-inf), left(NULL), right(NULL) {        }
        
        inline void pushUp(){
            maxv = max(left->maxv, right->maxv);
            sum = left->sum + right->sum;
        }
}SegTreeNode;

typedef class SegTree {
    public:
        SegTreeNode* root;
        SegTree():root(NULL){        }
        SegTree(int size, int* list, int* keyer){
            build(root, 1, size, list, keyer);
        }
        
        void build(SegTreeNode*& node, int l, int r, int* list, int* keyer) {
            node = new SegTreeNode();
            if(l == r) {
                node->maxv = list[keyer[l]];
                node->sum = list[keyer[l]];
                return;
            }
            int mid = (l + r) >> 1;
            build(node->left, l, mid, list, keyer);
            build(node->right, mid + 1, r, list, keyer);
            node->pushUp();
        }
        
        void update(SegTreeNode*& node, int l, int r, int index, int val) {
            if(l == index && r == index) {
                node->maxv = val;
                node->sum = val;
                return;
            }
            int mid = (l + r) >> 1;
            if(index <= mid)    update(node->left, l, mid, index, val);
            else update(node->right, mid + 1, r, index, val);
            node->pushUp();
        }
        
        int query_max(SegTreeNode*& node, int l, int r, int from, int end){
            if(l == from && r == end){
                return node->maxv;
            }
            int mid = (l + r) >> 1;
            if(end <= mid)    return query_max(node->left, l, mid, from, end);
            if(from > mid)    return query_max(node->right, mid + 1, r, from, end);
            int a = query_max(node->left, l, mid, from, mid);
            int b = query_max(node->right, mid + 1, r, mid + 1, end);
            return max(a, b);
        }
        
        long long query_sum(SegTreeNode*& node, int l, int r, int from, int end){
            if(l == from && r == end){
                return node->sum;
            }
            int mid = (l + r) >> 1;
            if(end <= mid)    return query_sum(node->left, l, mid, from, end);
            if(from > mid)    return query_sum(node->right, mid + 1, r, from, end);
            return query_sum(node->left, l, mid, from, mid) + query_sum(node->right, mid + 1, r, mid + 1, end);;
        }
}SegTree;

int cid, clink;
int* starter;        //重链的开始位置 
//int* dep;            //节点深度 
int* id;            //编号(一条重链上的编号是连续的) 
int* visit;            //记录访问顺序 
int* size;            //节点的大小 
int* zson;            //节点的重儿子编号 
int* belong;        //节点属于的重链的编号 
int* linkdep;        //重链的深度 
int* fa;            //节点的父节点 
MapManager g;
SegTree st;

void dfs1(int node, int last) {
    size[node] = 1;
    int maxs = 0, maxid = 0;
    for(int i = m_begin(g, node); i != 0; i = g[i].next) {
        int& e = g[i].end;
        if(e == last)    continue;
        dfs1(e, node);
        if(size[e] > maxs)    maxs = size[e], maxid = e;
        size[node] += size[e];
    }
    zson[node] = maxid;
}

void dfs2(int node, int last, boolean iszson){
     id[node] = ++cid;
     visit[cid] = node;
     belong[node] = (iszson) ? (belong[last]) : (++clink);
     if(!iszson)    starter[clink] = node, linkdep[belong[node]] = linkdep[belong[last]] + 1;
     fa[node] = last;
     if(zson[node] != 0)    dfs2(zson[node], node, true);
     for(int i = m_begin(g, node); i != 0; i = g[i].next) {
         int& e = g[i].end;
         if(e == last || e == zson[node])    continue;
         dfs2(e, node, false);
     }
}

int n, m;
int *v;

int lca_max(int a, int b) {
    int maxv = -inf;
    while(belong[a] != belong[b]){
        int& d = (linkdep[belong[a]] > linkdep[belong[b]]) ? (a) : (b);
        int res = st.query_max(st.root, 1, n, id[starter[belong[d]]], id[d]);
        d = fa[starter[belong[d]]], smax(maxv, res);
    }
    if(id[a] > id[b])    swap(a, b);
    int res = st.query_max(st.root, 1, n, id[a], id[b]);
    return max(res, maxv);
}

long long lca_sum(int a, int b) {
    long long sum = 0;
    while(belong[a] != belong[b]){
        int& d = (linkdep[belong[a]] > linkdep[belong[b]]) ? (a) : (b);
        sum += st.query_sum(st.root, 1, n, id[starter[belong[d]]], id[d]);
        d = fa[starter[belong[d]]];
    }
    if(id[a] > id[b])    swap(a, b);
    long long res = st.query_sum(st.root, 1, n, id[a], id[b]);
    return res + sum;
}

inline void init() {
    readInteger(n);
    g = MapManager(n, 2 * n);
    v = new int[(const int)(n + 1)];
    for(int i = 1, a, b; i < n; i++){
        readInteger(a);
        readInteger(b);
        g.addDoubleEdge(a, b);
    }
    for(int i = 1; i <= n; i++) readInteger(v[i]);
}

inline void init_tl() {
    int logn = n;
    starter = new int[(const int)(logn + 1)];
    id = new int[(const int)(n + 1)];
    visit = new int[(const int)(n + 1)];
    size = new int[(const int)(n + 1)];
    zson = new int[(const int)(n + 1)];
    belong = new int[(const int)(n + 1)];
    linkdep = new int[(const int)(logn + 1)];
    fa = new int[(const int)(n + 1)];
    belong[0] = 0;
    linkdep[0] = 0;
    cid = clink = 0;
    dfs1(1, 0);
    dfs2(1, 0, false);
    st = SegTree(n, v, visit);
}

inline void solve() {
    readInteger(m);
    char cmd[10];
    int a, b;
    while(m--) {
        scanf("%s", cmd);
        readInteger(a);
        readInteger(b);
        if(cmd[0] == 'C'){
            v[a] = b;
            st.update(st.root, 1, n, id[a], b);
        }else{
            if(cmd[1] == 'M'){
                int res = lca_max(a, b);
                printf("%d
", res);
            }else{
                long long res = lca_sum(a, b);
                printf(AUTO"
", res);
            }
        }
    }
}

int main() {
    init();
    init_tl();
    solve();
    return 0;
}