SPOJ 375 Query on a tree（树链剖分）

https://vjudge.net/problem/SPOJ-QTREE

题意：

给出一棵树，树上的每一条边都有权值，现在有查询和更改操作，如果是查询，则要输出u和v之间的最大权值。

思路：

树链剖分的模板题。

树链剖分简单来说，就是把树分成多条链，然后再将这些链映射到数据结构上处理（线段树，树状数组等等）。

具体的话可以看看这个http://blog.sina.com.cn/s/blog_6974c8b20100zc61.html

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<cstdio>
 #include<vector>
 #include<stack>
 #include<queue>
 #include<cmath>
 #include<map>
 #include<set>
 using namespace std;
 typedef long long ll;
 const int INF = 0x3f3f3f3f;
 const int maxn=+;

 int n;
 int tot;
 int pos;
 int head[maxn];
 int dep[maxn];  //节点在树上的深度
 int top[maxn];  //节点所在重链的顶端节点
 int num[maxn];  //节点的子节点数
 int fa[maxn];   //父亲结点
 int p[maxn];    //节点与其父亲结点在线段树中的位置
 int fp[maxn];   //和p数组相反
 int son[maxn];  //节点的重儿子
 int e[maxn][];

 struct node
 {
     int v,next;
 }edge[*maxn];

 void addEdge(int u, int v)
 {
     edge[tot].v=v;
     edge[tot].next=head[u];
     head[u]=tot++;
 }

 //求出重儿子等等
 void dfs(int u, int pre, int d)
 {
     dep[u]=d;
     son[u]=-;
     num[u]=;
     fa[u]=pre;
     for(int i=head[u];i!=-;i=edge[i].next)
     {
         int v=edge[i].v;
         if(v==pre)  continue;
         dfs(v,u,d+);
         num[u]+=num[v];
         if(son[u]==- || num[son[u]]<num[v])  //找到子节点最多的作为重儿子
             son[u]=v;
     }
 }

 //处理top值以及在线段树上的位置
 void getpos(int u, int sp)
 {
     top[u]=sp;
     if(son[u]!=-)  //先处理重儿子
     {
         p[u]=pos++;  //保证了一条链上的顶点在线段树上连续
         fp[p[u]]=u;
         getpos(son[u],sp);
     }
     else  //到了叶子节点就不再往下处理
     {
         p[u]=pos++;
         fp[p[u]]=u;
         return;
     }
     for(int i=head[u];i!=-;i=edge[i].next) //处理其他顶点
     {
         int v=edge[i].v;
         if(v==son[u] || v==fa[u])  continue;
         getpos(v,v);
     }
 }

 int val[maxn<<];
 int MAX[maxn<<];

 void PushUp(int o)
 {
     MAX[o]=max(MAX[o<<],MAX[o<<|]);
 }

 void build(int l, int r, int o)
 {
     if(l==r)
     {
         MAX[o]=val[l];
         return;
     }
     int mid=(l+r)>>;
     build(l,mid,o<<);
     build(mid+,r,o<<|);
     PushUp(o);
 }

 void update(int pos, int x, int l, int r, int o)
 {
     if(l==r)  {MAX[o]=x;return;}
     int mid=(l+r)>>;
     if(pos<=mid)  update(pos,x,l,mid,o<<);
     else     update(pos,x,mid+,r,o<<|);
     PushUp(o);
 }

 int query(int ql, int qr, int l, int r, int o)
 {
     if(ql<=l && qr>= r)  return MAX[o];
     int mid=(l+r)>>;
     int res=;
     if(ql<=mid)  res=max(res,query(ql,qr,l,mid,o<<));
     if(qr>mid)   res=max(res,query(ql,qr,mid+,r,o<<|));
     return res;
 }

 int lca(int x, int y)
 {
     int ans=;
     while(top[x]!=top[y])  //不在一条链上时
     {
         if(dep[top[x]]<dep[top[y]])  swap(x,y);  //从深度较深的开始
         ans=max(ans,query(p[top[x]],p[x],,n,));
         x=fa[top[x]];  //x所在链的顶点的父节点，转到另一条链上
     }
     if(dep[x]>dep[y])  swap(x,y);
     if(x!=y)  ans=max(ans,query(p[son[x]],p[y],,n,));
     return ans;
 }

 int main()
 {
     //freopen("in.txt","r",stdin);
     int T;
     scanf("%d",&T);
     while(T--)
     {
         tot=;
         memset(head,-,sizeof(head));
         scanf("%d",&n);
         for(int i=;i<n;i++)
         {
             scanf("%d%d%d",&e[i][],&e[i][],&e[i][]);
             addEdge(e[i][],e[i][]);
             addEdge(e[i][],e[i][]);
         }
         dfs(,,);
         pos=;
         getpos(,);
         for(int i=;i<n;i++)
         {
             if(dep[e[i][]]<dep[e[i][]]) swap(e[i][],e[i][]);
             val[p[e[i][]]]=e[i][];
         }
         build(,n,);
         char s[]; int u,v;
         while(scanf("%s",s))
         {
             if(s[]=='D') break;
             scanf("%d%d",&u,&v);
             if(s[]=='Q')  printf("%d\n",lca(u,v));
             else  update(p[e[u][]],v,,n,);
         }
     }
     return ;
 }