树链剖分

用途

解决树的上路径修改，查询等操作，时间复杂度$O(R\times log_2n)$(R为维护的其它数据结构复杂度，一般为线段树$R=log_2n$）。

主要思路

将整棵树的边分为轻边和重边，将每个重边连成的链当作一个区间，用维护区间的数据结构去维护它。

如何选择重边

一般选连接子树所含节点最多的儿子作为重边，如图：

这样可以保证从根节点到任何一个节点，最多只有$log_2n$个重边链。

简单说明最坏情况：

实现技巧

标号

我们可以给这棵树重新标号，使得每一条重链的点编号为连续的，更方便使用线段树维护，如上图的树：

构建数据结构

有两种实现
一种是使用一棵线段树，维护整个区间，代码复杂度很低，缺点是不能在$O(1)$的时间复杂度下查询整个重链。
另一种是给每一个重链建一棵线段树，代码复杂度就很恶心了，但可以$O(1)$查询重链信息。

查询路径

初始化时记录每个节点所在重链的最高点top，节点到根的距离（深度dep）。
更新从a到b的路径的信息：

1.如果a与b不在同一个重链(top[a]!=top[b])
    2.选择a与b更深的一个点c(dep更大）
    3.更新c到top[c]重链
    4.c:=top[c]的父亲
    5.重复1
6.此时a与b在同一个重链，更新a到b的路径

代码

SPOJ QTREE（使用一棵线段树）

//SPOJ QTREE
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=20005;

struct Edge
{
    int v;
    Edge *nxt;
}E[MAXN*2],*V[MAXN],*cur;
void add_edge(int u,int v)
{
    cur->v=v,cur->nxt=V[u];
    V[u]=cur++;
    cur->v=u,cur->nxt=V[v];
    V[v]=cur++;
}

int val[MAXN];

//Heavy-Light Decomposition
int fa[MAXN],dep[MAXN],siz[MAXN],son[MAXN];
int tid[MAXN],rnk[MAXN],top[MAXN],dcnt;
void dfs1(int u,int pa,int deep)
{
    fa[u]=pa;
    dep[u]=deep;
    siz[u]=1;
    son[u]=0;
    int mx=0;
    for(Edge *p=V[u];p;p=p->nxt)
    {
        int v=p->v;
        if(v!=pa)
        {
            dfs1(v,u,deep+1);
            siz[u]+=siz[v];
            if(mx<siz[v])
            mx=siz[v],son[u]=v;
        }
    }
}
void dfs2(int u,int tp)
{
    tid[u]=++dcnt;
    rnk[dcnt]=u;
    top[u]=tp;
    if(son[u]==0)return;
    dfs2(son[u],tp);
    for(Edge *p=V[u];p;p=p->nxt)
    {
        int v=p->v;
        if(v!=fa[u]&&v!=son[u])
            dfs2(v,v);
    }
}

//segment tree
int mx[MAXN*4],mxpos;
void PushUp(int u)
{mx[u]=max(mx[u*2],mx[u*2+1]);}
void Build(int u=1,int L=1,int R=mxpos)
{
    if(L==R)
    {
        mx[u]=val[rnk[L]];
        return;
    }
    int mid=(L+R)/2;
    Build(u*2,L,mid);
    Build(u*2+1,mid+1,R);
    PushUp(u);
}
void Modify(int pos,int nval,int u=1,int L=1,int R=mxpos)
{
    if(L==pos&&R==pos)
    {
        mx[u]=nval;
        return;
    }
    int mid=(L+R)/2;
    if(pos<=mid)
        Modify(pos,nval,u*2,L,mid);
    if(pos>mid)
        Modify(pos,nval,u*2+1,mid+1,R);
    PushUp(u);
}
int Query(int l,int r,int u=1,int L=1,int R=mxpos)
{
    if(R<l||r<L)return 0;
    if(l<=L&&R<=r)
        return mx[u];
    int mid=(L+R)/2,res=0;
    res=Query(l,r,u*2,L,mid);
    res=max(res,Query(l,r,u*2+1,mid+1,R));
    return res;
}
int QueryPath(int a,int b)
{
    int ans=0;
    while(top[a]!=top[b])
    {
        if(dep[top[a]]>dep[top[b]])
            swap(a,b);
        ans=max(ans,Query(tid[top[b]],tid[b]));
        b=fa[top[b]];
    }
    if(dep[a]>dep[b])
        swap(a,b);
    ans=max(ans,Query(tid[a],tid[b]));
    return ans;
}

void Init(int n)
{
    cur=E;
    memset(V,0,sizeof V);
    memset(val,0,sizeof val);
    memset(mx,0,sizeof mx);
    mxpos=n+n-1;
    dcnt=0;
}
int main()
{
    int T,n;
    char op[10];
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        Init(n);
        for(int i=1,a,b,c;i<n;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            val[n+i]=c;
            add_edge(a,n+i);
            add_edge(n+i,b);
        }
        dfs1(1,0,1);
        dfs2(1,1);
        Build();
        while(true)
        {
            scanf("%s",op);
            if(op[0]=='D')
                break;
            int a,b;
            scanf("%d%d",&a,&b);
            if(op[0]=='C')
                Modify(tid[a+n],b);
            else
                printf("%d\n",QueryPath(a,b));
        }
    }
    return 0;
}

SPOJ QTREE5（使用多棵线段树维护）

//SPOJ QTREE5
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int MAXN=100005;
const int IMAX=0x7F7F7F7F,IMIN=0x80808080;

struct Heap
{
    priority_queue< int,vector<int>,greater<int> >heap,del;
    void push(int u)
    {heap.push(u);}
    void erase(int u)
    {del.push(u);}
    int top()
    {
        while(!del.empty()&&heap.top()==del.top())
            heap.pop(),del.pop();
        return heap.top();
    }
    int size()
    {return heap.size()-del.size();}
};

struct Edge
{
    int v;
    Edge *nxt;
}E[MAXN*2],*V[MAXN],*ecnt=E;
void add_edge(int u,int v)
{
    ecnt->v=v;ecnt->nxt=V[u];
    V[u]=ecnt++;
    ecnt->v=u;ecnt->nxt=V[v];
    V[v]=ecnt++;
}

int fa[MAXN],son[MAXN],siz[MAXN],dep[MAXN];
int top[MAXN],tid[MAXN],rnk[MAXN],csiz[MAXN],dcnt;
void dfs1(int u,int pa,int deep)
{
    fa[u]=pa;dep[u]=deep;
    siz[u]=1;son[u]=0;
    int best=0;
    for(Edge *p=V[u];p;p=p->nxt)
    {
        int v=p->v;
        if(v!=pa)
        {
            dfs1(v,u,deep+1);
            siz[u]+=siz[v];
            if(best<siz[v])
                best=siz[v],son[u]=v;
        }
    }
}
void dfs2(int u,int tp)
{
    tid[u]=++dcnt;
    rnk[dcnt]=u;
    top[u]=tp;
    csiz[tp]++;
    if(son[u]==0)return;
    dfs2(son[u],tp);
    for(Edge *p=V[u];p;p=p->nxt)
    {
        int v=p->v;
        if(v!=fa[u]&&v!=son[u])
            dfs2(v,v);
    }
}

struct Node
{
    int mnl,mnr;
    Node *lc,*rc;
};
Node *root[MAXN],nodes[MAXN*2],*ncnt=nodes;
bool col[MAXN];
Heap oth[MAXN];

void Update(Node *u,int id)
{
    int res=IMAX;
    if(col[id])
        res=0;
    if(oth[id].size())
        res=min(res,oth[id].top()+1);
    u->mnl=u->mnr=res;
}
void PushUp(Node *u,int L,int R)
{
    int mid=(L+R)/2;
    u->mnl=min(u->lc->mnl,u->rc->mnl+mid+1-L);
    u->mnr=min(u->lc->mnr+R-mid,u->rc->mnr);
}
void Build(Node *&u,int L,int R)
{
    if(u==NULL)u=ncnt++;
    if(L==R)
    {
        int t=rnk[L];
        for(Edge *p=V[t];p;p=p->nxt)
        {
            int v=p->v;
            if(v!=fa[t]&&top[v]!=top[t])
            {
                Build(root[top[v]],tid[v],tid[v]+csiz[top[v]]-1);
                oth[t].push(root[top[v]]->mnl+1);
            }
        }
        Update(u,t);
        return;
    }
    int mid=(L+R)/2;
    Build(u->lc,L,mid);
    Build(u->rc,mid+1,R);
    PushUp(u,L,R);
}
void Modify(int pos,int od,int nw,Node *u,int L,int R)
{
    if(pos==L&&R==pos)
    {
        if(od!=-1)
        {
            int t=rnk[pos];
            oth[t].erase(od);
            oth[t].push(nw);
        }
        Update(u,rnk[pos]);
        return;
    }
    int mid=(L+R)/2;
    if(pos<=mid)
        Modify(pos,od,nw,u->lc,L,mid);
    else
        Modify(pos,od,nw,u->rc,mid+1,R);
    PushUp(u,L,R);
}
int Query(int l,int r,bool f,Node *u,int L,int R)
{
    if(l<=L&&R<=r)
        return f?u->mnr:u->mnl;
    int mid=(L+R)/2,r1=IMAX,r2=IMAX;
    if(l<=mid)
    {
        r1=Query(l,r,f,u->lc,L,mid);
        if(f&&r>mid)r1+=r-mid;
    }
    if(r>mid)
    {
        r2=Query(l,r,f,u->rc,mid+1,R);
        if(!f&&l<=mid)r2+=mid+1-l;
    }
    return min(r1,r2);
}
void Modify(int u)
{
    int od=-1,nw=-1,t;
    while(u)
    {
        t=root[top[u]]->mnl;
        Modify(tid[u],od,nw,root[top[u]],tid[top[u]],tid[top[u]]+csiz[top[u]]-1);
        od=t;
        nw=root[top[u]]->mnl;
        u=fa[top[u]];
    }
}
int Query(int u)
{
    int res=IMAX,dis=0,last=u;
    while(u)
    {
        res=min(res,Query(tid[u],tid[top[u]]+csiz[top[u]]-1,0,root[top[u]],tid[top[u]],tid[top[u]]+csiz[top[u]]-1)+dis);
        res=min(res,Query(tid[top[u]],tid[u],1,root[top[u]],tid[top[u]],tid[top[u]]+csiz[top[u]]-1)+dis);
        last=u;
        u=fa[top[u]];
        dis+=dep[last]-dep[u];
    }
    return res;
}

int main()
{
    int N,Q,op,a,b,cnt=0;
    scanf("%d",&N);
    for(int i=1;i<N;i++)
    {
        scanf("%d%d",&a,&b);
        add_edge(a,b);
    }

    dfs1(1,0,1);
    dfs2(1,1);
    Build(root[1],tid[1],tid[1]+csiz[1]-1);

    scanf("%d",&Q);
    for(int i=1;i<=Q;i++)
    {
        scanf("%d%d",&op,&a);
        if(op==0)
        {
            if(col[a])
                cnt--,col[a]=0;
            else
                cnt++,col[a]=1;
            Modify(a);
        }
        else
        {
            if(cnt==0)puts("-1");
            else printf("%d\n",Query(a));
        }
    }
    return 0;
}