SPOJ QTREE-Query on a tree-树链剖分-边权

用每个点代表父节点到此点的边。建立一一映射后就可以用点权的方法处理了。

注意的是路径两端节点的处理

 #include <cstdio>
 #include <algorithm>
 #include <vector>

 using namespace std;

 const int maxn = 1e5+;
 int val[maxn],dep[maxn],siz[maxn],top[maxn],id[maxn],son[maxn],fa[maxn];
 int topw,M;

 vector<int> G[maxn];
 struct Edge{
     int x,y,val;
 }e[maxn];

 void dfs_1(int u,int f,int d)
 {
     fa[u] = f;
     son[u] = ;
     siz[u] = ;
     dep[u] = d;

     for(int i=;i<G[u].size();i++) if(G[u][i] != f )
     {
         dfs_1(G[u][i],u,d+);
         siz[u] += siz[G[u][i]];
         if(siz[son[u] ] < siz[G[u][i] ])
         {
             son[u] = G[u][i];
         }
     }
 }

 void dfs_2(int u,int tp)
 {
     top[u] = tp;
     id[u] = ++topw;
     if(son[u]) dfs_2(son[u],tp);
     for(int i=;i<G[u].size();i++) if(G[u][i] != fa[u] && G[u][i] != son[u])
     {
         dfs_2(G[u][i],G[u][i]);
     }
 }

 int N,T;

 void debug()
 {
     for(int i=;i<=N;i++)
     {
         printf("%d siz:%d son:%d dep:%d fa:%d ",i,siz[i],son[i],dep[i],fa[i]);
         printf("top:%d id:%d\n",top[i],id[i]);
     }
 }

 /*-------------------------------------*/
 //segment Tree
 #define lson(x) (x<<1)
 #define rson(x) (x<<1|1)

 struct SegmentTree{
     int l,r,val;
 }sgtree[*maxn];

 void pushup(int x)
 {
     sgtree[x].val = max(sgtree[lson(x)].val,sgtree[rson(x)].val);
 }

 void Build(int l,int r,int x)
 {
     sgtree[x].l = l;
     sgtree[x].r = r;
     if(l==r)
     {
         sgtree[x].val = val[l];
         return ;
     }
     int mid = (l+r)>>;
     Build(l,mid,lson(x));
     Build(mid+,r,rson(x));
     pushup(x);
 }

 void update(int x,int v,int add)
 {
     if(sgtree[x].l == sgtree[x].r)
     {
         sgtree[x].val = add;
         //printf("change:%d %d\n",v,sgtree[x].l);
         return ;
     }
     int mid = (sgtree[x].l+sgtree[x].r)>>;
     if(v <= mid) update(lson(x),v,add);
     else         update(rson(x),v,add);
     pushup(x);
 }

 int query(int x,int l,int r)
 {
     if(sgtree[x].l >= l && sgtree[x].r <= r)
     {
         return sgtree[x].val;
     }
     int mid = (sgtree[x].l+sgtree[x].r)>>;
     int ans = ;
     if(l <= mid) ans = max(ans,query(lson(x),l,r));
     if(r >  mid) ans = max(ans,query(rson(x),l,r));
     return ans;
 }

 int Find(int u,int v)
 {
     int ans = ,fu = top[u],fv = top[v];
     while(fu != fv)
     {
         if(dep[fu] < dep[fv])
         {
             swap(fu,fv);swap(u,v);
         }
         ans = max(ans,query(,id[fu],id[u]));
         u = fa[fu];
         fu = top[u];
     }
     if(u == v) return ans;
     if(dep[u]>dep[v]) swap(u,v);
     return max(ans,query(,id[son[u] ],id[v]));
 }

 int main()
 {
     //freopen("input.in","r",stdin);
     scanf("%d",&T);
     while(T--)
     {
         scanf("%d",&N);
         for(int i=,a,b,c;i<N;i++)
         {
             scanf("%d%d%d",&a,&b,&c);
             e[i].x = a;
             e[i].y = b;
             e[i].val = c;
             G[a].push_back(b);
             G[b].push_back(a);
         }
         topw = ;
         dfs_1(,,);
         dfs_2(,);
         //debug();

         for(int i=;i<N;i++)
         {
             if(dep[e[i].x] < dep[e[i].y]) swap(e[i].x,e[i].y);
             val[id[e[i].x]] = e[i].val;
         }

         Build(,topw,);
         char op[];
         while(scanf("%s",op) && op[] != 'D')
         {
             int a,b;
             scanf("%d%d",&a,&b);
             if(op[] == 'Q')
                 printf("%d\n",Find(a,b));
             else if(op[] == 'C')
                 update(,id[e[a].x],b);
         }

         for(int i=;i<=N;i++) G[i].clear();
     }
 }