pku2763 Housewife Wind

题意：给定一棵有n（ n < 100001 ）个结点的带边权的树,处理以下一共q（q < 100001）个操作：

1，改变树的一条边的权；

2，求给定点和某点的距离，后者是编号为1的结点，若是第一次执行操作2，否则为上次执行操作2的给定点。

没有了操作1，这题就是典型的LCA，于是怎样有效地执行操作1就是这题的关键。还记得LCA到RMQ的转化吗点我，过程中DFS会生成一条回路，并且产生一个从遍历次序到结点编号的满射，我们称它为order[]。我们知道，若以结点到根的距离作为树的深度，如果一条边的权增加了delta，那么这条边链接的子树内的所有结点的深度都增加了delta。又因为子树内的结点的遍历次序是连续的，所以我们可以建立从 遍历次序 到 到根的距离的映射dist[]，于是每次执行操作1只需对dist[]的一片连续区域作修改即可，可以用线段树或者树状数组。

搞定了操作1，我们发现操作2也被搞出来了，因为LCA(u,v)=order[RMQ(dist[出现u的任意遍历序号...出现v的任意遍历序号])]，可能这是出题者的意图吧。

 

 

#include  < iostream >
#include  < vector >
#include  < cmath >
using   namespace  std;

#define  MAXN 200005
#define  LOG 20
typedef pair < int , int >  PAIR;


int  order[MAXN],ecnt,dist[MAXN],first[MAXN],last[MAXN],n,q,st,p[MAXN],maxorder,c[MAXN],mn[MAXN][LOG],b[MAXN];
// first[u]表示u首次出现的遍历序号,last[u]表示u最后出现的遍历序号
bool  visited[MAXN];

struct  Edge{
     int  v,weight,next;
}edg[MAXN];


void  init(){
    ecnt = 0 ;
    memset(p, - 1 , sizeof (p));
    memset(dist, 0 , sizeof (dist));
    maxorder = 1 ;
    memset(visited, false , sizeof (visited));
    memset(c, 0 , sizeof (c));
}


void  dfs( int  pre, int  u, int  w){
     int  i,v,ordertmp;
    
    visited[u] = true ;
    last[u] = first[u] = maxorder;
    order[maxorder] = u;
    dist[maxorder] = dist[last[pre]] + w;
    ordertmp = maxorder ++ ;

     for (i = p[u];i !=- 1 ;i = edg[i].next){
        v = edg[i].v;
         if ( ! visited[v]){
            
            dfs(u,v,edg[i].weight);
            order[maxorder] = u;
            last[u] = maxorder;
            dist[maxorder] = dist[ordertmp];
            maxorder ++ ;
        }
    }
}

//////////////////////////////////////////////////////////////////////// //
// 树状数组
inline  int  lowbit( int  x){
     return  x & ( - x);
}


int  down( int  x){
     int  i,res = 0 ;
     for (i = x;i > 0 ;i -= lowbit(i))
        res += c[i];
     return  res;
}

void  up( int  x, int  t){
     int  i;
     for (i = x;i < maxorder;i += lowbit(i))
        c[i] += t;
}

void  build(){
     int  i;
     for (i = 1 ;i < maxorder;i ++ )
        b[i] = dist[i] - dist[i - 1 ];
     for (i = 1 ;i < maxorder;i ++ ){
        up(i,b[i]);
    }
}

//////////////////////////////////////////////////////////////////////// //
// spares table
void  preprocess(){
     int  i,j;
     for (i = 1 ;i < maxorder;i ++ )
        mn[i][ 0 ] = i;
     for (j = 1 ;( 1 << j) <= maxorder;j ++ ){
         for (i = 1 ;i + ( 1 << j) - 1 < maxorder;i ++ ){
             if (dist[mn[i][j - 1 ]] <= dist[mn[i + ( 1 << (j - 1 ))][j - 1 ]])
                mn[i][j] = mn[i][j - 1 ];
             else
                mn[i][j] = mn[i + ( 1 << (j - 1 ))][j - 1 ];

        }
    }
}

int  RMQ( int  i, int  j){
     if (i > j){
         int  t = i;
        i = j;
        j = t;
    }
     int  k = log(( double )j - i + 1 ) / log(( double ) 2 );
     if (dist[mn[i][k]] <= dist[mn[j - ( 1 << k) + 1 ][k]])
         return  mn[i][k];
     else
         return  mn[j - ( 1 << k) + 1 ][k];
}

//////////////////////////////////////////////////////////////////////// //
// main
int  main(){
     int  i,j,u,v,weight,flag,w;
    init();
    vector < PAIR >  vec;
    scanf( " %d%d%d " , & n, & q, & st);
     for (i = 0 ;i < n - 1 ;i ++ ){
        scanf( " %d%d%d " , & u, & v, & weight);
        vec.push_back(make_pair(u,v));
        edg[ecnt].next = p[u];
        edg[ecnt].v = v;
        edg[ecnt].weight = weight;
        p[u] = ecnt ++ ;
        edg[ecnt].next = p[v];
        edg[ecnt].v = u;
        edg[ecnt].weight = weight;
        p[v] = ecnt ++ ;
    }

    dfs( 1 , 1 , 0 );

//      for(i=1;i<maxorder;i++)
//          printf("%d ",order[i]);
//      printf("\n");
//      for(i=1;i<maxorder;i++)
//          printf("%d ",dist[i]);
//      printf("\n");
//      for(i=1;i<=n;i++)
//          printf("%d ",first[i]);
//      printf("\n");
//      for(i=1;i<=n;i++)
//          printf("%d ",last[i]);
//      printf("\n");

    build();
    preprocess();

     for (i = 0 ;i < q;i ++ ){
        scanf( " %d " , & flag);
         if (flag){
            scanf( " %d%d " , & j, & weight);
            j -- ;
            u = vec[j].first;
            v = vec[j].second;
             if (dist[first[u]] > dist[first[v]]){
                 int  t = u;
                u = v;
                v = t;
            }
            w = down(first[v]) - down(first[u]);
            up(first[v],weight - w);
             if (last[v] + 1 < maxorder)
                up(last[v] + 1 ,w - weight);
        }
         else {
            scanf( " %d " , & u);
            v = order[RMQ(first[u],first[st])];
            printf( " %d\n " ,down(first[u]) + down(first[st]) - 2 * down(first[v]));
            st = u;
        }
    }
     return   0 ;
}