SPOJ 375 树链剖分

SPOJ 375
题目链接：
题意：
思路：
首先感谢这位博主http://blog.csdn.net/y990041769/article/details/40348013，基本照着打的。
昨晚打CF的时候遇到一道树链剖分的版题，今天顺便就学了一下……然后就学了一天。

这是一道树链剖分的版题。
树链剖分用于对一个带权值的树（边权或点权，边权可以通过下面代码类似的转化方式转成点权，但是查询的时候需要相应处理）进行查询操作（最值，和）。
首先树链剖分据说有很多种，目前只掌握了轻重链剖分的一种。
重链即子节点的子树中节点个数最多的那个子节点。如果有多个则任取一个。轻链是其他的所有链。
构建操作：
然后这样去构建一个线段树。因为每次都会先遍历一个点的重链，所以线段树的区间就是一段重链一段轻链的形式连接起来的。
查询操作：
对于树上两个点u、v，如果u和v不在一条重链上，则所在重链深度大的先更新（重链深度以重链顶端的那个起点为准）。当在一个重链上时，在对这个重链进行单独的查询操作。
修改操作：
线段树的单点修改。
源码：

#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <string>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAXN = 10000 + 5;
int son[MAXN], num[MAXN], dep[MAXN], fa[MAXN];  ///重链子节点、以其为根的子树节点个数、节点深度、结点的父节点
int tp[MAXN], cnt, id[MAXN];                    ///所在重链的顶点、编号数、每个点的编号
vector<int>lin[MAXN];                           ///每个点的相邻点
int n;
struct E                                        ///存边
{
    int u, v, val;
    void read(){
        scanf("%d%d%d", &u, &v, &val);
    }
}e[MAXN];
void dfs1(int u, int f, int deep)           ///简单深搜形成有根数，统计深度、父节点、子树的节点个数、重链子节点
{
    fa[u] = f, dep[u] = deep, num[u] = 1;
    son[u] = 0;
    for(int i = 0 ; i < (int)lin[u].size() ; i++){
        int v = lin[u][i];
        if(v == f)  continue;
        dfs1(v, u, deep + 1);
        num[u] += num[v];
        if(num[son[u]] < num[v])    son[u] = v;
    }
}
void dfs2(int u, int f)                 ///用于给结点编号，优先遍历重链子节点
{
    id[u] = ++cnt;
    tp[u] = f;
    if(son[u])  dfs2(son[u], f);
    for(int i = 0 ; i < (int)lin[u].size() ; i++){
        int v = lin[u][i];
        if(v == fa[u] || v == son[u])   continue;
        dfs2(v, v);
    }
}
int val[MAXN];                          ///本题是边权，所以把边权赋给深度小的结点
struct Tree
{
    int l, r, val;
    void init(int _l, int _r){l = _l, r = _r;}
}tree[MAXN * 4];
void push_up(int o)                     ///线段树的操作
{
    tree[o].val = max(tree[o*2].val, tree[o*2 + 1].val);
}
void build(int l, int r, int o)         ///线段树的操作
{
    tree[o].init(l, r);
    if(l == r){
        tree[o].val = val[l];
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, o * 2);
    build(mid + 1, r, o * 2 + 1);
    push_up(o);
}
int query(int o, int l, int r)              ///线段树的操作
{
    if(tree[o].l >= l && tree[o].r <= r)    return tree[o].val;
    int mid = (tree[o].l + tree[o].r) >> 1;
    int ans = 0;
    if(l <= mid)    ans = max(ans, query(o * 2, l, r));
    if(mid < r)     ans = max(ans, query(o * 2 + 1, l, r));
    return ans;
}
void modify(int o, int u, int v)            ///修改，线段树的操作
{
    if(tree[o].l == tree[o].r){
        tree[o].val = v;
        return;
    }
    int mid = (tree[o].l + tree[o].r) / 2;
    if(u <= mid)    modify(o * 2, u, v);
    else     modify(o * 2 + 1, u, v);
    push_up(o);
}
char op[200];
int solve(int u, int v)                 ///查询操作
{
    int ans = 0;
    int tp1 = tp[u], tp2 = tp[v];
    while(tp1 != tp2){                  ///在同一条重链时才退出
//        printf("u = %d, v = %d, tp1 = %d, tp2 = %d\n", u, v, tp1, tp2);
        if(dep[tp1] < dep[tp2]) swap(tp1, tp2), swap(u, v);         ///设u为所在重链深度大的点
        ans = max(ans, query(1, id[tp1], id[u]));
        u = fa[tp1];                                                ///u更新为所在重链顶点 的父节点，再重新更新所在重链顶点的父节点
        tp1 = tp[u];
//        printf("ans = %d\n", ans);
    }
//        printf("u = %d, v = %d, tp1 = %d, tp2 = %d\n", u, v, tp1, tp2);
    if(u == v)  return ans;
    if(dep[u] > dep[v]) swap(u, v);
    ans = max(ans, query(1, id[son[u]], id[v]));                    ///由于点权是有边权转化来的，所以id[u]是不在u-v区间内的，id[son[u]]-v区间才是所求
    return ans;
}
int main()
{
    int T;
    scanf("%d", &T);
    while(T--){
        scanf("%d", &n);
        for(int i = 1 ; i <= n - 1 ; i++){
            e[i].read();
            lin[e[i].u].push_back(e[i].v);
            lin[e[i].v].push_back(e[i].u);
        }

        cnt = 0;
        dfs1(1, 0, 1);
        dfs2(1, 1);
//        val[1] = 1;
        for(int i = 1 ; i <= n - 1 ; i++){
            if(dep[e[i].u] < dep[e[i].v])   swap(e[i].u, e[i].v);
            val[id[e[i].u]] = e[i].val;
        }
        build(1, cnt, 1);
        while(~scanf("%s", op) && op[0] != 'D'){
            int u, v;
            scanf("%d%d", &u, &v);
            if(op[0] == 'Q')    printf("%d\n", solve(u, v));
            else    modify(1, id[e[u].u], v);
        }
        for(int i = 0 ; i <= n ; i++)   lin[i].clear();
    }
    return 0;
}