bzoj 2209 括号序列

反转操作 + 翻转操作 = 对称操作

因为上面三个操作都是自己的逆操作,所以我们只需要实现对称操作和反转操作,就可以搞定翻转操作.

 #include <cstdio>
 #include <algorithm>
 #define N 100010
 using namespace std;

 struct Node {
     int siz, val, clf[], crg[], rtag, etag;
     Node *ch[], *par;
     void update() {
         int v;
         v = (ch[]?ch[]->crg[]:) + val - (ch[]?ch[]->clf[]:);
         clf[] = (ch[]?ch[]->clf[]:), crg[] = (ch[]?ch[]->crg[]:);
         if( v> ) crg[]+=v;
         else clf[]+=-v;
         v = (ch[]?ch[]->crg[]:) + (-val) - (ch[]?ch[]->clf[]:);
         clf[] = (ch[]?ch[]->clf[]:), crg[] = (ch[]?ch[]->crg[]:);
         if( v> ) crg[]+=v;
         else clf[]+=-v;
         siz = (ch[]?ch[]->siz:) +  + (ch[]?ch[]->siz:);
     }
     void pushdown() {
         if( rtag ) {
             if( ch[] ) ch[]->reverse();
             if( ch[] ) ch[]->reverse();
             rtag = ;
         }
         if( etag ) {
             if( ch[] ) ch[]->exchange();
             if( ch[] ) ch[]->exchange();
             etag = ;
         }
     }
     void reverse() {
         swap( ch[], ch[] );
         swap( clf[], crg[] );
         swap( clf[], crg[] );
         rtag ^= ;
     }
     void exchange() {
         swap( clf[], clf[] );
         swap( crg[], crg[] );
         val = -val;
         etag ^= ;
     }
 }pool[N], *tail=pool, *root;

 int n, m;
 char buf[N];

 Node *find( int pos ) {
     Node *nd = root;
     pos++;
     while() {
         nd->pushdown();
         int lz = nd->ch[]?nd->ch[]->siz:;
         if( pos<=lz ) {
             nd=nd->ch[];
         } else if( pos==lz+ ){
             return nd;
         } else {
             pos -= lz+;
             nd=nd->ch[];
         }
     }
 }
 void rotate( Node *nd, int d ) {
     Node *p = nd->par;
     Node *s = nd->ch[!d];
     Node *ss = s->ch[d];

     if( !p ) root=s;
     else p->ch[ nd==p->ch[] ] = s;
     if( s ) s->ch[d] = nd;
     nd->ch[!d] = ss;

     nd->par = s;
     s->par = p;
     if( ss ) ss->par = nd;

     nd->update();
     s->update();
 }
 void bigpush( Node *nd ) {
     if( !nd ) return;
     bigpush(nd->par);
     nd->par->pushdown();
 }
 void splay( Node *nd, Node *top= ) {
     while( nd->par!=top ) {
         Node *p = nd->par;
         int nl = nd==p->ch[];
         if( p->par==top ) {
             rotate( p, nl );
         } else {
             Node *pp = p->par;
             int pl = p==pp->ch[];
             if( nl==pl ) {
                 rotate( pp, pl );
                 rotate( p, nl );
             } else {
                 rotate( p, nl );
                 rotate( pp, pl );
             }
         }
     }
 }
 Node *fetch( int lf, int rg ) {
     Node *nl = find(lf-);
     Node *nr = find(rg+);
     splay(nl);
     splay(nr,nl);
     return nr->ch[];
 }
 Node *newnode( Node *par, int v ) {
     Node *nd = ++tail;
     nd->par = par;
     nd->ch[] = nd->ch[] = ;
     nd->siz = ;
     nd->val = v;
     nd->clf[] = v==-;
     nd->crg[] = v==;
     nd->clf[] = -v==-;
     nd->crg[] = -v==;
     nd->rtag = nd->etag = ;
     return nd;
 }
 Node *build( Node *par, int lf, int rg ) {
     if( lf>rg ) return ;
     int mid=(lf+rg)>>;
     Node *nd = newnode( par, buf[mid]=='('?:- );
     nd->ch[] = build( nd, lf, mid- );
     nd->ch[] = build( nd, mid+, rg );
     nd->update();
     return nd;
 }
 int query( int lf, int rg ) {
     Node *nd = fetch(lf,rg);
     return ((nd->clf[]+)>>)+((nd->crg[]+)>>);
 }

 int main() {
     scanf( "%d%d", &n, &m );
     scanf( "%s", buf+ );
     buf[] = '(';
     buf[n+] = ')';
     root = build( , , n+ );
     for( int i=,o,l,r; i<=m; i++ ) {
         scanf( "%d%d%d", &o, &l, &r );
         if( o== ) {
             printf( "%d\n", query(l,r) );
         } else if( o== ) {
             fetch(l,r)->exchange();
         } else {
             fetch(l,r)->reverse();
         }
     }
 }