简单树链剖分

题目引入：树的统计

Description

　　一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。
　　我们将以下面的形式来要求你对这棵树完成一些操作：
　　I. CHANGE u t : 把结点u的权值改为t
　　II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值
　　III. QSUM u v: 询问从点u到点v的路径上的节点的权值和
　　注意：从点u到点v的路径上的节点包括u和v本身

Input

　　输入文件的第一行为一个整数n，表示节点的个数。
　　接下来n – 1行，每行2个整数a和b，表示节点a和节点b之间有一条边相连。
　　接下来n行，每行一个整数，第i行的整数wi表示节点i的权值。
　　接下来1行，为一个整数q，表示操作的总数。
　　接下来q行，每行一个操作，以“CHANGE u t”或者“QMAX u v”或者“QSUM u v”的形式给出。

Output

　　对于每个“QMAX”或者“QSUM”的操作，每行输出一个整数表示要求输出的结果。

Sample Input

4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4

Sample Output

4
1
2
2
10
6
5
6
5
16

Data Constraint

　　对于100％的数据，保证1<=n<=30000，0<=q<=200000；中途操作中保证每个节点的权值w在-30000到30000之间。

大意：

在一棵树上，每次查询或修改两个点的最短路径上的值。
这里只用单点修改，有区间修改是一样的，把线段树改一下即可。
至于可持久化，自己YY。

---

转载一篇博客，它里面讲得已经很详细了，不过它是维护边的的值，这里是维护点的值，有略微不同。

“在一棵树上进行路径的修改、求极值、求和”乍一看只要线段树就能轻松解决，实际上，仅凭线段树是不能搞定它的。我们需要用到一种貌似高级的复杂算法——树链剖分。

树链，就是树上的路径。剖分，就是把路径分类为重链和轻链。

记：

siz[v]表示以v为根的子树的节点数
dep[v]表示v的深度(根深度为1)
top[v]表示v所在的重链的顶端节点
fa[v]表示v的父亲
son[v]表示与v在同一重链上的v的儿子节点（姑且称为重儿子）
w[v]表示v与其父亲节点的连边（姑且称为v的父边）在线段树中的位置。

只要把这些东西求出来，就能用logn的时间完成原问题中的操作。

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

---

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

---

算法实现：

我们可以用两个dfs来求出fa、dep、siz、son、top、w。

dfs_1：

把fa、dep、siz、son求出来，比较简单，略过。

dfs_2：

⒈对于v，当son[v]存在（即v不是叶子节点）时，显然有top[son[v]] = top[v]。线段树中，v的重边应当在v的父边的后面，记w[son[v]] = totw+1，totw表示最后加入的一条边在线段树中的位置。此时，为了使一条重链各边在线段树中连续分布，应当进行dfs_2(son[v])；

2.对于v的各个轻儿子u，显然有top[u] = u，并且w[u] = totw+1，进行dfs_2过程。
这就求出了top和w。
将树中各边的权值在线段树中更新，建链和建线段树的过程就完成了。

---

修改操作：例如将u到v的路径上每条边的权值都加上某值x。
一般人需要先求LCA，然后慢慢修改u、v到公共祖先的边。而高手就不需要了。
记f1 = top[u]，f2 = top[v]。
当f1 <> f2时：不妨设dep[f1] >= dep[f2]，那么就更新u到f1的父边的权值(logn)，并使u = fa[f1]。
当f1 = f2时：u与v在同一条重链上，若u与v不是同一点，就更新u到v路径上的边的权值(logn)，否则修改完成；
重复上述过程，直到修改完成。

求和、求极值操作：类似修改操作，但是不更新边权，而是对其求和、求极值。
就这样，原问题就解决了。鉴于鄙人语言表达能力有限，咱画图来看看：树链剖分

---

如右图所示，较粗的为重边，较细的为轻边。节点编号旁边有个红色点的表明该节点是其所在链的顶端节点。边旁的蓝色数字表示该边在线段树中的位置。图中1-4-9-13-14为一条重链。

当要修改11到10的路径时。
第一次迭代：u = 11，v = 10，f1 = 2，f2 = 10。此时dep[f1] < dep[f2]，因此修改线段树中的5号点，v = 4, f2 = 1；
第二次迭代：dep[f1] > dep[f2]，修改线段树中10–11号点。u = 2，f1 = 2；
第三次迭代：dep[f1] > dep[f2]，修改线段树中9号点。u = 1，f1 = 1；
第四次迭代：f1 = f2且u = v，修改结束。

---

数据规模大时，递归可能会爆栈，而非递归dfs会很麻烦，所以可将两个dfs改为宽搜+循环。即先宽搜求出fa、dep，然后逆序循环求出siz、son，再顺序循环求出top和w。

---

我的猥琐标：

#include<cstdio>
#include<string>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#define fo(i,x,y) for(int i=x;i<=y;i++)
using namespace std; 

const int maxn=300005;

int n,q;

int v[maxn],bz[maxn];

int tot,final[maxn],to[maxn*2],next[maxn*2];

int fa[maxn],son[maxn],dep[maxn],siz[maxn],top[maxn],w[maxn],totw;

int d[maxn*4],ds[maxn*4];

char chs[10];

void swap(int &x,int &y) {
    int z=x; x=y; y=z;
}

void pls(int i,int x,int y,int l,int c) {
    if(x == y) {
        ds[i] += c; 
        d[i] += c;
    } else {
        int m = (x + y) / 2;
        if(l<=m)
            pls(i+i,x,m,l,c); else pls(i+i+1,m+1,y,l,c);
        ds[i]=ds[i + i]+ds[i + i +1];
        d[i]=max(d[i + i],d[i + i + 1]);
    }
}

int finds(int i,int x,int y,int l,int r) {
    if(l > r) return 0;
    if(x == l && y == r) return ds[i];
    int m = (x + y) / 2;
    if(r <= m) return finds(i + i,x,m,l,r);
    if(l > m) return finds(i + i +1,m + 1,y,l,r);
    return finds(i + i,x,m,l,m)+finds(i + i + 1,m + 1,y,m + 1,r);
}

int find(int i,int x,int y,int l,int r){
    if(l > r) return 0;
    if(x == l && y == r) return d[i];
    int m = (x+y) /2;
    if(r <= m) return find(i + i,x,m,l,r);
    if(l > m) return find(i + i +1,m + 1,y,l,r);
    int p=find(i + i,x,m,l,m),q=find(i + i + 1,m + 1,y,m + 1,r);
    return max(p,q);
} 

void init();

void dfs1(int);

void dfs2(int,int);

void At_last();

int main() {
    init();
    dep[1] = 1, dfs1(1);
    top[1] = 1, dfs2(1,0);
    fo(i,1,n) pls(1,1,n,w[i],v[i]);
    At_last();
}

void init() {
    scanf("%d", &n);
    fo(i,1,n-1) {
        int x,y; scanf("%d %d", &x, &y);
        next[++tot] = final[x],to[tot] = y,final[x] = tot;
        next[++tot] = final[y],to[tot] = x,final[y] = tot;
    }
    fo(i,1,n) scanf("%d", &v[i]);
}

void At_last() {
    for(scanf("%d", &q);q;q--) {
        scanf("%s",chs);
        int len=strlen(chs);

        int bz=0;
        if(len == 6) bz=1; else 
        if(len == 4 && chs[3]=='X') bz=2; else 
        bz=3;

        int x,y;
        scanf("%d %d",&x,&y);

        if(bz == 1) {
            pls(1,1,n,w[x],y-v[x]),v[x]=y; 
        }else {
            int ans=0;
            if(bz==2) ans=-1E9;
            while(x != 0 || y!=0) {
                int f1=top[x],f2=top[y];

                if(dep[f1]<dep[f2])
                    swap(f1,f2), swap(x,y);

                if(f1 != f2) {
                    if(bz == 2)
                        ans=max(ans,find(1,1,n,w[f1],w[x])); else ans+=finds(1,1,n,w[f1],w[x]);
                    x=fa[f1];
                } else {
                    if(w[x]>w[y]) swap(x,y);
                    if(bz == 2)
                        ans=max(ans,find(1,1,n,w[x],w[y])); else ans+=finds(1,1,n,w[x],w[y]);
                    x=y=0;
                }
            }
            printf("%d\n",ans); 
        }
    }
}

void dfs1(int x) {
    siz[x] = 1;
    for(int i = final[x];i;i = next[i]) {
        int y = to[i]; if(dep[y]) continue;
        dep[y] = dep[x]+1;
        fa[y] = x;
        dfs1(y);
        siz[x]+=siz[y];
        if(siz[y] > siz[son[x]])
            son[x] = y;
    }
}

void dfs2(int x,int last){
    w[x] = ++totw; 
    if(son[x] != 0)
        top[son[x]] = top[x], dfs2(son[x],x);
    for(int i = final[x];i;i = next[i]) {
        int y = to[i]; if(y == last || y == son[x]) continue;
        top[y] = y;
        dfs2(y,x);
    }
}