SPOJ 375 (树链剖分+线段树)

题意：一棵包含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\n",lca(x,y));
			}
			else if(str[0]=='C')
			{
				scanf("%d%d",&i,&w);
				update(1,ti[E[i].x],w);
			}
		}
		printf("\n");
	}
	return 0;
}