题意：一棵包含N 个结点的树，每条边都有一个权值，要求模拟两种操作：(1)改变某条边的权值,(2)询问U,V 之间的路径中权值最大的边。
思路：最近比赛总是看到有树链剖分的题目，就看了论文，做了这题，思路论文上讲的很清楚了，好长时间没写线段树了，错了好几遍。对树进行轻重边路径剖分。对于询问操作，我们可以分别处理两个点到其最近公共祖先的路径。路径可以分解成最多O(log N)条轻边和O(log N)条重路径，那么只需考虑如何维护这两种对象。对于轻边，我们直接处理即可。而对于重路径，我们只需用线段树来维护。
#include<stdio.h>
#include <iostream>
#include <string.h>
using namespace std;
const int N=210000;
const int inf=0x3fffffff;
int son[N],father[N],sz[N],head[N],num,ti[N],idx,dep[N],top[N];
struct edge
{
int ed,next;
}e[N*3];
struct Edge
{
int x,y,w;
}E[N*2];
int max(int a,int b)
{
if(a>b)return a;
return b;
}
void addedge(int x,int y)
{
e[num].ed=y;e[num].next=head[x];head[x]=num++;
e[num].ed=x;e[num].next=head[y];head[y]=num++;
}
//****************************树链部分***********************
//siz[u]u的子节点个数
//top[u]u所在链顶点
//father[u]表示u的父节点
//son[u]与u在同重链上的儿子节点
//ti[u]表示u与其父亲节点的连边，在线段树中的位置
void dfs_find(int u,int fa)
{
int i,v;
sz[u]=1;dep[u]=dep[fa]+1;son[u]=0;father[u]=fa;
for(i=head[u];i!=-1;i=e[i].next)
{
v=e[i].ed;
if(v==fa)continue;
dfs_find(v,u);
sz[u]+=sz[v];
if(sz[son[u]]<sz[v])son[u]=v;
}
}
void dfs_time(int u,int fa)
{
int i,v;
ti[u]=idx++;
top[u]=fa;
if(son[u]!=0)dfs_time(son[u],top[u]);
for(i=head[u];i!=-1;i=e[i].next)
{
v=e[i].ed;
if(v==father[u]||v==son[u])continue;
dfs_time(e[i].ed,e[i].ed);//该链的顶点就是该点
}
}
//***************************线段树部分*************************
struct tree
{
int L,R,w;
}T[N<<2];
void buildTree(int L,int R,int id)
{
T[id].L=L;T[id].R=R;T[id].w=-inf;
if(L==R) return;
int mid=(L+R)>>1;
buildTree(L,mid,id*2);
buildTree(mid+1,R,id*2+1);
}
void update(int id,int cp,int w)
{
if(T[id].L==T[id].R)
{T[id].w=w;return;}
int mid=(T[id].L+T[id].R)>>1;
if(mid>=cp)update(id*2,cp,w);
else update(id*2+1,cp,w);
T[id].w=max(T[id*2].w,T[id*2+1].w);
}
int query(int L,int R,int id)
{
if(T[id].R==R&&T[id].L==L)
return T[id].w;
int mid=(T[id].R+T[id].L)>>1;
if(mid>=R)return query(L,R,id*2);
else if(mid<L)return query(L,R,id*2+1);
else return max(query(L,mid,id*2),query(mid+1,R,id*2+1));
}
int lca(int x,int y)
{
int ans=-inf;
while(top[x]!=top[y])
{
if(dep[top[x]]<dep[top[y]])swap(x,y);
ans=max(ans,query(ti[top[x]],ti[x],1));//x到所在链的顶点所有边的最大值
x=father[top[x]];//x所在链的顶点的父节点，转到另一条链上
}
if(dep[x]>dep[y])swap(x,y);
if(x!=y)
ans=max(ans,query(ti[x]+1,ti[y],1));//ti[x]指的是x与其父亲的边，所以+1
return ans;
}
int main()
{
int i,n,t,x,y,w;
char str[100];
scanf("%d",&t);
while(t--)
{
memset(head,-1,sizeof(head));
num=0;
scanf("%d",&n);
for(i=1;i<n;i++)
{
scanf("%d%d%d",&E[i].x,&E[i].y,&E[i].w);
addedge(E[i].x,E[i].y);
}
dep[1]=0;sz[0]=0;idx=1;
dfs_find(1,1);
dfs_time(1,1);
buildTree(2,n,1);
for(i=1;i<n;i++)
{
if(dep[E[i].x]<dep[E[i].y])
swap(E[i].x,E[i].y);
update(1,ti[E[i].x],E[i].w);
}
while(true)
{
scanf("%s",str);
if(str[0]=='D')break;
else if(str[0]=='Q')
{
scanf("%d%d",&x,&y);
printf("%d
",lca(x,y));
}
else if(str[0]=='C')
{
scanf("%d%d",&i,&w);
update(1,ti[E[i].x],w);
}
}
printf("
");
}
return 0;
}