树链剖分 375. Query on a tree

树链剖分并不是一个复杂的算法或者数据结构，只是能把一棵树拆成链来处理而已，换一种说法，树链剖分只是xxx数据结构/算法在树上的推广，或者说，树链剖分只是把树hash到了几段连续的区间上。

主要参考kuangbin ：http://www.cnblogs.com/kuangbin/category/507663.html

以及 http://blog.sina.com.cn/s/blog_7a1746820100wp67.html

第二个其中的修改操作的解释好像有问题，

其例子中查询11和10 的实际的遍历和他的解释有不同，

 原来是：

当要修改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，修改结束。

我认为应该是：

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

题目链接：http://www.spoj.com/problems/QTREE/

const double eps = 1e-10;
const int MAXN = 10010;


struct Edge{
    int to, next, l;
};
Edge adj[MAXN * 2];
int head[MAXN], tol;


int top[MAXN];///top[v]表示v所在重链的顶端定点
int fa[MAXN];///fa[v]表示v的父节点,没有为-1
int deep[MAXN];///deep[v]表示v在树中的深度，根点为1
int num[MAXN];///num[v]表示以v为根的子树的节点数


int son[MAXN];///重儿子，没有为-1
///int sonid[MAXN]
int p[MAXN];///p[v]表示v和其父亲节点的连边在线段树的位置（标号)
int fp[MAXN];///和p数组相反
int pos;


void init()
{
    tol = 0;///init_edge
    CLR(head, -1);


    pos = 0;///init_p
    CLR(son, -1);
}
void add_edge(int u, int v, int l)
{
    adj[tol].to = v;
    adj[tol].l = l;
    adj[tol].next = head[u];
    head[u] = tol++;
}
void dfs1(int u, int pre, int d)///求出fa, deep, num, son
{
    deep[u] = d;
    fa[u] = pre;
    num[u] = 1;
    for (int r = head[u]; r != -1; r = adj[r].next)
    {
        int v = adj[r].to;
        if (v != pre)
        {
            dfs1(v, u, d + 1);
            num[u] += num[v];
            if (son[u] == -1 || num[v] > num[son[u]])
                son[u] = v;
        }
    }
}


void getpos(int u, int sp)///top, p, fp
{
    top[u] = sp;
    p[u] = ++pos;
    fp[p[u]] = u;
    if (son[u] != -1) getpos(son[u], sp);
    else return ;
    for (int r = head[u]; r != -1; r = adj[r].next)
    {
        int v = adj[r].to;
        if (v != son[u] && v != fa[u])
            getpos(v, v);
    }
}


///线段树求最大值
#define lson l, m, rt << 1
#define rson m + 1, r, rt << 1 | 1
int s[MAXN << 2];
void pushup(int rt)
{
    s[rt] = max(s[rt << 1], s[rt << 1 | 1]);
}
void update(int p, int x, int l, int r, int rt)
{
    if (l == r)
    {
        s[rt] = x;
        return ;
    }
    int m = (l + r) >> 1;
    if (p <= m) update(p, x, lson);
    else update(p, x, rson);
    pushup(rt);
}
int query(int L, int R, int l, int r, int rt)
{
    if (L <= l && r <= R)
    {
        return s[rt];
    }
    int m = (l + r) >> 1;
    int ret = 0;
    if (L <= m) ret = max(ret, query(L, R, lson));
    if (R > m) ret = max(ret, query(L, R, rson));
    return ret;
}
int find(int u, int v)
{
    int fu = top[u];
    int fv = top[v];
    int tmp = 0;
    while (fu != fv)
    {
        if (deep[fu] < deep[fv])
        {
            swap(fu, fv);
            swap(u, v);
        }
        tmp = max(tmp, query(p[fu], p[u], 1, pos, 1));
        u = fa[fu]; fu = top[u];
    }
    if (u == v) return tmp;
    if (deep[u] > deep[v]) swap(u, v);
    return max(tmp, query(p[son[u]], p[v], 1, pos, 1)); ///如果是点剖分的话query(p[u], p[v], 1, pos, 1)

}
int n;
int e[MAXN][3];
int main ()
{
    int T;
    RI(T);
    while (T--)
    {
        init();
        RI(n);
        FE(i, 1, n - 1)
        {
            RIII(e[i][0], e[i][1], e[i][2]);
            add_edge(e[i][0], e[i][1], e[i][2]);
            add_edge(e[i][1], e[i][0], e[i][2]);
        }
        dfs1(1, -1, 1);
        getpos(1, 1);
        CLR(s, 0);///初始化线段树
        FE(i, 1, n - 1)
        {
            if (deep[e[i][0]] > deep[e[i][1]])
                swap(e[i][0], e[i][1]);
            update(p[e[i][1]], e[i][2], 1, pos, 1);
        }
        char op[10];
        int u, v;
        while (scanf("%s", op) == 1)
        {
            if (op[0] == 'D') break;
            scanf("%d%d",&u, &v);
            if (op[0] == 'Q')
                printf("%d\n", find(u, v));
            else update(p[e[u][1]], v, 1, pos, 1);
        }
    }
    return 0;
}