bzoj 1095 括号序列求两点距离

大致题意: 给一棵树,每个节点最开始都是黑色,有两种操作,1.询问树中相距最远的一对黑点的距离 2.反转一个节点的颜色

一种做法:

　　建立出树的括号序列,类似这样: [A[B][C]],所以长度为3*n

　　假如我们要询问AC间的距离,提取出中间的括号:[]],匹配消去后得到],其长度就是距离.

　　现在我们要做的就是修改点的状态,并且动态维护答案.要用到一些求与绝对值相关的式子的技巧.

 /**************************************************************
     Problem: 1095
     User: idy002
     Language: C++
     Result: Accepted
     Time:2176 ms
     Memory:55548 kb
 ****************************************************************/

 #include <cstdio>
 #define min(a,b) ((a)<(b)?(a):(b))
 #define max(a,b) ((a)>(b)?(a):(b))
 #define N 100010
 #define M N<<1
 #define oo 0x3f3f3f3f
 #define fprintf(...)

 struct Node {
     int v[], c, e, a;
     int lf, rg;
     Node *ls, *rs;
     void init( int type ) {
         if( type== ) {
             a = ;
             e = false;
             c = ;
             for( int t=; t<; t++ ) v[t]=;
         } else if( type==- ) { //  (1,0)
             a = -;
             e = true;
             c = ;
             v[] = v[] = v[] = v[] = v[] = ;
             v[] = v[] = -;
         } else {                //  (0,1)
             a = -;
             e = true;
             c = ;
             v[] = v[] = v[] = v[] = v[] = ;
             v[] = v[] = -;
         }
     }
     void update() {
         e = ls->e && rs->e;
         v[] = ls->v[] + rs->v[];
         v[] = ls->v[] + rs->v[];
         v[] = max( ls->v[]+rs->v[], ls->v[]+rs->v[] );
         if( !ls->e && !rs->e ) {
             v[] = max( ls->v[], ls->v[]+rs->v[] );
             v[] = max( ls->v[], max( ls->v[]+rs->v[], ls->v[]+rs->v[] ) );
             v[] = max( rs->v[], ls->v[]+rs->v[] );
             v[] = max( rs->v[], max( ls->v[]+rs->v[], ls->v[]+rs->v[] ) );
             a = max( max(ls->v[]+rs->v[],ls->v[]+rs->v[]), max(ls->a,rs->a) );
         } else if( !ls->e ) {
             v[] = ls->v[];
             v[] = ls->v[];
             v[] = ls->v[]+rs->v[];
             v[] = max( ls->v[]+rs->v[], ls->v[]+rs->v[] );
             a = ls->a;
         } else if( !rs->e ) {
             v[] = ls->v[]+rs->v[];
             v[] = max( ls->v[]+rs->v[], ls->v[]+rs->v[] );
             v[] = rs->v[];
             v[] = rs->v[];
             a = rs->a;
         } else {
             a = -;
         }
     }
     void reverse( int pos ) {
         if( lf==rg ) {
             if( c ) {
                 c = ;
                 a = -;
                 e = true;
             } else {
                 c = ;
                 a = ;
                 e = false;
             }
             return;
         }
         int mid=(lf+rg)>>;
         if( pos<=mid ) ls->reverse(pos);
         else rs->reverse(pos);
         update();
     }
 }pool[N**], *tail=pool, *root;

 int n, m;
 int head[N], dest[M], next[M], etot;
 int dfn[N], sgn[N*], fat[N], idc;

 void adde( int u, int v ) {
     etot++;
     next[etot] = head[u];
     dest[etot] = v;
     head[u] = etot;
 }
 void dfs( int u ) {
     sgn[++idc] = ;
     dfn[u] = ++idc;
     fprintf( stderr, "[" );
     fprintf( stderr, "%d", u );
     for( int t=head[u]; t; t=next[t] ) {
         int v=dest[t];
         if( v==fat[u] ) continue;
         fat[v] = u;
         dfs(v);
     }
     sgn[++idc] = -;
     fprintf( stderr, "]" );
 }
 Node *build( int lf, int rg ) {
     Node *nd = ++tail;
     nd->lf=lf, nd->rg=rg;
     if( lf==rg ) {
         nd->init( sgn[lf] );
     } else {
         int mid=(lf+rg)>>;
         nd->ls = build( lf, mid );
         nd->rs = build( mid+, rg );
         nd->update();
     }
     fprintf( stderr, "[%d,%d] a=%2d e=%d v[0~6] = %2d %2d %2d %2d %2d %2d %2d\n",
             lf, rg, nd->a, nd->e, nd->v[], nd->v[],
             nd->v[], nd->v[], nd->v[], nd->v[], nd->v[] );
     return nd;
 }
 int main() {
     scanf( "%d", &n );
     for( int i=,u,v; i<n; i++ ) {
         scanf( "%d%d", &u, &v );
         adde( u, v );
         adde( v, u );
     }
     for( int i=; i<=n+n+n; i++ )
         fprintf( stderr, "%d", i% );
     fprintf( stderr, "\n" );
     fat[] = ;
     dfs();
     fprintf( stderr, "\n" );
     root = build( , idc );
     scanf( "%d", &m );
     for( int i=,u; i<=m; i++ ) {
         char ch[];
         scanf( "%s\n", ch );
         if( ch[]=='G' ) {
             printf( "%d\n", root->a );
         } else {
             scanf( "%d", &u );
             root->reverse(dfn[u]);
         }
     }
 }

另一种做法大概是用点分,然后用堆维护最值.