bzoj 3306

以1号节点为根，弄出DFS序，我们发现，对于一个询问：(rt,u)，以rt为根，u节点的子树中的最小点权，我们可以根据rt,u,1这三个节点在同一条路径上的相对关系来把它转化为以1为根的在DFS序上的区间询问（中间有一种情况要在树上倍增，理解了LCA的话应该很容易写出来）。

收获：

对于只有换根这种改变树的形态的操作，又只询问和子树相关的问题，可以不用动态树。

 /**************************************************************
     Problem: 3306
     User: idy002
     Language: C++
     Result: Accepted
     Time:2264 ms
     Memory:19948 kb
 ****************************************************************/

 #include <cstdio>
 #include <iostream>
 #define oo 0x3f3f3f3f
 #define N 100010
 #define P 16
 using namespace std;

 struct Node {
     int v;
     Node *ls, *rs;
 }pool[N*], *tail=pool, *root;

 int n, m;
 int head[N], wght[N], dest[N+N], next[N+N], etot;
 int anc[N][P+], dep[N], in[N], out[N], vdf[N], idc;

 void update( Node *nd ) {
     nd->v = min( nd->ls->v, nd->rs->v );
 }
 Node *build( int lf, int rg ) {
     Node *nd = ++tail;
     if( lf==rg ) {
         nd->v = wght[vdf[lf]];
         return nd;
     }
     int mid=(lf+rg)>>;
     nd->ls = build( lf, mid );
     nd->rs = build( mid+, rg );
     update( nd );
     return nd;
 }
 void modify( Node *nd, int lf, int rg, int pos, int val ) {
     if( lf==rg ) {
         nd->v = val;
         return;
     }
     int mid=(lf+rg)>>;
     if( pos<=mid ) modify( nd->ls, lf, mid, pos, val );
     else modify( nd->rs, mid+, rg, pos, val );
     update(nd);
 }
 int query( Node *nd, int lf, int rg, int L, int R ) {
     if( L<=lf && rg<=R )
         return nd->v;
     int mid=(lf+rg)>>;
     int rt = oo;
     if( L<=mid ) rt = query( nd->ls, lf, mid, L, R );
     if( R>mid ) rt = min( rt, query( nd->rs, mid+, rg, L, R ) );
     return rt;
 }
 void adde( int u, int v ) {
     etot++;
     next[etot] = head[u];
     dest[etot] = v;
     head[u] = etot;
 }
 void dfs( int u ) {
     ++idc;
     in[u] = idc;
     vdf[idc] = u;
     for( int p=; p<=P; p++ )
         anc[u][p] = anc[anc[u][p-]][p-];
     for( int t=head[u]; t; t=next[t] ) {
         int v=dest[t];
         anc[v][] = u;
         dep[v] = dep[u]+;
         dfs(v);
     }
     out[u] = idc;
 }
 int climb( int u, int t ) {
     for( int p=; t; t>>=,p++ )
         if( t& ) u=anc[u][p];
     return u;
 }
 int lca( int u, int v ) {
     if( dep[u]<dep[v] ) swap(u,v);
     int t=dep[u]-dep[v];
     u = climb( u, t );
     if( u==v ) return u;
     for( int p=P; p>=&&anc[u][]!=anc[v][]; p-- )
         if( anc[u][p]!=anc[v][p] ) u=anc[u][p],v=anc[v][p];
     return anc[u][];
 }
 int query( int rt, int u ) {
     int ca=lca(rt,u);
     if( rt==u ) {
         return query( root, , idc, , idc );
     } else if( ca==u ) {
         int ans1=oo, ans2=oo;
         u = climb( rt, dep[rt]-dep[u]- );
         if( in[u]>= ) ans1 = query( root, , idc, , in[u]- );
         if( out[u]<=n- ) ans2 = query( root, , idc, out[u]+, idc );
         return min( ans1, ans2 );
     } else {
         return query( root, , idc, in[u], out[u] );
     }
 }
 int main() {
     scanf( "%d%d", &n, &m );
     for( int i=,f,w; i<=n; i++ ) {
         scanf( "%d%d", &f, &w );
         wght[i] = w;
         if( f ) adde(f,i);
     }
     anc[][] = ;
     dep[] = ;
     dfs();
     root = build( , idc );

     int crt=;
     for( int t=,x,y; t<=m; t++ ) {
         char ch[];
         scanf( "%s", ch );

         if( ch[]=='V' ) {
             scanf( "%d%d", &x, &y );
             modify( root, , idc, in[x], y );
         } else if( ch[]=='E' ) {
             scanf( "%d", &crt );
         } else {
             scanf( "%d", &x );
             printf( "%d\n", query(crt,x) );
         }
     }
 }