SPOJ QTREE Query on a tree

题意：
给一颗n个点的树，有两种操作
CHANGE i ti : 把第i条边的权变为ti
QUERY a b : 问点a 到 点b 之间的边的最大权

思路：
树剖处理边权。
由于是边，所以只需要把边权处理到子节点上即可(查询的时候从节点2开始查询，或者把0处理成负无穷)

具体见代码：

 const int maxn =  + ;
 const int maxnode = maxn * ;

 //线段树部分
 int set_value, qL, qR;
 int maxv[maxnode];

 void update(int o, int L, int R)
 {
     if (qL <= L && R <= qR)
     {
         maxv[o] = set_value;
         return;
     }
     int M = L + (R - L) / ;
     if (qL <= M) update(lson);
     if (qR > M) update(rson);
     maxv[o] = max(maxv[o*], maxv[o*+]);
 }

 int query(int o, int L, int R) {
     if (qL <= L && R <= qR)
     {
         return maxv[o];
     }
     int M = L + (R - L) / ;
     int ret = -INF;
     if (qL <= M) ret = max(ret, query(lson));
     if (qR > M) ret = max(ret, query(rson));
     return ret;
 }

 //树链剖分部分：
 //
 //u为连接的点，w为边权
 struct Edge { int u, v, w; };
 vector<int> G[maxn];
 vector<Edge> e;
 //往往是双向边
 void add_edge(int u, int v, int w)
 {
     e.push_back((Edge){u, v, w});
     G[u].push_back(v);
     G[v].push_back(u);
 }

 struct Node
 {
     int size, dep, son, top, fa, ti;
     //依次表示第i个节点的：
     //子节点数量，深度，所在链的顶端，重儿子，dfs序
 } t[maxn];

 int dfs_clock;//DFS时间序列

 void dfs1(int u, int pa, int depth)//第一次DFS，得到size,dep,fa以及son的数据
 {
     t[u].son = ; //重儿子，为0表示没有重儿子
     t[u].size = ;    //节点数量
     t[u].dep = depth;
     t[u].fa = pa;
     for (int i = ; i != G[u].size(); ++ i)
     {
         int v = G[u][i];
         if (v == pa) continue;
         dfs1(v, u, depth + );
         t[u].size += t[v].size;
         if (t[v].size > t[t[u].son].size) t[u].son = v;
     }
 }

 void dfs2(int u, int pa)    // 得到时间戳等数据,u为当前节点，pa为父链顶端节点
 {
     t[u].ti = ++ dfs_clock; //u这个节点的时间戳是dfs_clock,dfs_clock下标是从1开始的，没有0！
     t[u].top = pa;        //top是u所在链的顶端
     if (t[u].son != ) dfs2(t[u].son, t[u].top);    //如果节点有重儿子，那么依旧是以pa为链顶端的一条链
     for (int i = ; i != G[u].size(); ++ i)
     {
         int v = G[u][i];
         if (v == t[u].son || v == t[u].fa)    continue;//重儿子或者父节点，则跳过
         dfs2(v, v);//新的一条链
     }
 }

 int n;
 int lca(int x, int y)//更新x到y的之间所有的区间
 {
     int ret = -INF;
     while (t[x].top != t[y].top)
     {
         if (t[t[x].top].dep < t[t[y].top].dep) swap(x,y); //x深 y浅
         qL=t[t[x].top].ti;
         qR=t[x].ti;
         ret = max(ret, query(, , n));
         x = t[t[x].top].fa;
     }
     if (t[x].dep > t[y].dep) swap(x, y);//x是上面一些的节点
     if (x != y)
     {
         qL = t[x].ti + ;
         qR = t[y].ti;
         ret = max(ret, query(, , n));
     }
     return ret;
 }

 void init()
 {
     memset(maxv, , sizeof(maxv));
     dfs_clock = ;
     scanf("%d", &n);
     for (int i = ; i <= n; i++) G[i].clear();
     e.clear();
     int u, v, w;
     for (int i = ; i < n; i++)
     {
         scanf("%d%d%d", &u, &v, &w);
         add_edge(u, v, w);
     }
 }

 void solve()
 {
     dfs1(, , );
     dfs2(, );

     for (int i = ; i < n; i++)
     {
         set_value = e[i-].w;
         if (t[e[i-].u].dep < t[e[i-].v].dep)
             qL = qR = t[e[i-].v].ti;
         else
             qL = qR = t[e[i-].u].ti;
         update(, , n);
     }
     char op[];
     int u, v;
     while (true)
     {
         scanf("%s", op);
         if (op[] == 'D') break;
         scanf("%d%d", &u, &v);
         if (op[] == 'Q')
         {
             printf("%d\n", lca(u, v));
         }
         else
         {
             set_value = v;
             if (t[e[u-].u].dep < t[e[u-].v].dep)
                 qL = qR = t[e[u-].v].ti;
             else
                 qL = qR = t[e[u-].u].ti;
             update(, , n);
         }
     }
     printf("\n");
 }

 int main()
 {
     int T;
     scanf("%d", &T);
     while (T--)
     {
         init();
         solve();
     }
     return ;
 }