FZU oj Problem 2082 过路费

                                                                                Problem 2082 过路费

Problem Description

有n座城市，由n-1条路相连通，使得任意两座城市之间可达。每条路有过路费，要交过路费才能通过。每条路的过路费经常会更新，现问你，当前情况下，从城市a到城市b最少要花多少过路费。

Input

有多组样例，每组样例第一行输入两个正整数n,m(2 <= n<=50000，1<=m <= 50000),接下来n-1行，每行3个正整数a b c，(1 <= a,b <= n , a != b , 1 <= c <= 1000000000).数据保证给的路使得任意两座城市互相可达。接下来输入m行，表示m个操作，操作有两种：一. 0 a b，表示更新第a条路的过路费为b，1 <= a <= n-1 ； 二. 1 a b ， 表示询问a到b最少要花多少过路费。

Output

对于每个询问，输出一行，表示最少要花的过路费。

 Sample Input

2 3

1 2 1

1 1 2

0 1 2

1 2 1

 Sample Output

1 2

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 using namespace std;
 const int maxn = ;
 int son[maxn]; //表示该点重链的子节点
 int num[maxn]; //表示以该点为根的子树的节点数量
 int dep[maxn]; //表示该节点的深度
 int fa[maxn];  // 表示该节点的父亲节点
 int vis[maxn]; // 表示该节点在线段树中的编号
 int top[maxn]; // 表示这条重链的顶端节点
 int is[maxn];
 int edge[maxn][];
 int now;
 struct Tree
 {
     int l;
     int r;
     int Sum;
 } tree[maxn*];
 struct node
 {
     int to,val;
 } p;
 vector<node>E[maxn];
 void init()
 {
     now=;
     memset(is,,sizeof(is));
     memset(son,-,sizeof(son));
     memset(tree,,sizeof(tree));
     for(int i=; i<maxn; i++)
         E[i].clear();
 }
 void dfs1(int u,int v,int step)    //第一遍dfs求出son，fa，num，dep
 {
     is[v]=;
     dep[v]=step;
     num[v]=;
     fa[v]=u;
     int len = E[v].size();
     for(int i=; i<len; i++)
     {
         int to = E[v][i].to;
         if(!is[to])
         {
             dfs1(v,to,step+);
             num[v]+=num[to];
             if(son[v]==-||num[son[v]]<num[to])
             {
                 son[v]=to;
             }
         }
     }
     return ;
 }
 void dfs2(int u,int v)         // 第二遍dfs求出top和vis
 {
     is[v]=;
     top[v]=u;
     vis[v]=now++;
     if(son[v]==-)
         return ;
     else
         dfs2(u,son[v]);
     int len = E[v].size();
     for(int i=; i<len; i++)
     {
         int to = E[v][i].to;
         if(!is[to])
         {
             if(to==fa[v]||to==son[v])
                 continue;
             dfs2(to,to);
         }
     }
 }
 void build(int v,int l,int r)
 {
     tree[v].l=l;
     tree[v].r=r;
     if( l == r )
     {
         tree[v].Sum=;
         return;
     }
     int mid=( l+r )>>;
     build( v<<,l,mid );
     build( v<<|,mid+,r );
     tree[v].Sum=;
 }
 int query( int v,int l,int r)
 {
     if (l==tree[v].l&&r==tree[v].r)
         return tree[v].Sum;
     int mid=(tree[v].l+tree[v].r)>>;
     if(l <= mid && r <= mid)
         return query(v<<,l,r);
     else if(l > mid)
         return query(v<<|,l,r);
     else
         return query(v<<,l,mid)+query(v<<|,mid+,r);
 }
 void update(int v,int x,int m)
 {
     int l,r;
     l = tree[v].l;
     r = tree[v].r;
     int mid = (l + r) / ;
     if(l == r)
     {
         tree[v].Sum = m;
         return;
     }
     if(x <= mid)
         update(v<<,x,m);
     else
         update(v<<|,x,m);
     tree[v].Sum=query(v<<,l,mid)+query(v<<|,mid+,r);
 }
 int main()
 {
     int n,m;
     while(~scanf("%d%d",&n,&m))
     {
         init();
         for(int i=; i<=n-; i++)
         {
             scanf("%d%d%d",&edge[i][],&edge[i][],&edge[i][]);
             p.to=edge[i][],p.val=edge[i][];
             E[edge[i][]].push_back(p);
             p.to=edge[i][],p.val=edge[i][];
             E[edge[i][]].push_back(p);
         }
         dfs1(,,);
         memset(is,,sizeof(is));
         dfs2(,);
         build(,,n);
         for(int i = ; i <= n-; i++)
         {
             if(dep[edge[i][]] < dep[edge[i][]])
                 swap(edge[i][],edge[i][]);
             update(,vis[edge[i][]]+,edge[i][]);
         }
         while(m--)
         {
             int x,y,z,q,w;
             scanf("%d%d%d",&x,&y,&z);
             if(x)
             {
                 q = top[y],w = top[z];
                 int ans = ;
                 while(q != w)     //不在一条重链上，就爬树
                 {
                     if(dep[q] < dep[w])
                     {
                         swap(q,w);
                         swap(y,z);
                     }
                     ans += query(,vis[q]+,vis[y]+);
                     y = fa[q];
                     q = top[y];
                 }
                 if(y != z)        //爬到一条重链上
                 {
                     if(dep[y] > dep[z])
                         swap(y,z);
                     ans += query(,vis[son[y]]+,vis[z]+);
                 }
                 printf("%d\n",ans);
             }
             else
             {
                 update(,vis[edge[y][]]+,z);
             }
         }

     }
     return ;
 }