【hdu5217-括号序列】线段树

题意：给一串括号，有2个操作，1。翻转某个括号。2。查询某段区间内化简后第k个括号是在原序列中的位置。1 ≤ N,Q ≤ 200000.

题解：

可以知道，化简后的序列一定是)))((((这种形式的。

线段树每个节点就存对应区间内化简后的ls也就是)的数量，rs也就是(的数量。

然后我先把区间[l,r]找出来合并一遍，找出第k个是哪一种扩号。

问题转化为找区间[l,r]中的第kk个左扩号或者右括号。

我们可以发现，如果是)这种括号，区间从左到右合并的时候是单调不减的。

同理，(这种括号，区间从右往左合并的时候也是单调不减的。

然后我是变成从左往右的第kk个），或者从右往左的第kk个（。

[l,r]这个区间在线段树里可能由若干个区间组合而来，我们就根据左右括号的不同从左或从右合一遍，恰好遇到第kk个的时候就进去找。这个找就简单很多，因为它就是在线段树上走一遍的。

细节挺多的。

 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 using namespace std;

 const int N=;
 int n,m,tl,cl,c[N];
 char s[N];
 struct node{
     int l,r,lc,rc,ls,rs;// ls ))) rs (((
 }t[*N];

 int maxx(int x,int y){return x>y ? x:y;}

 node upd(node x,node lc,node rc)
 {
     x.ls=lc.ls;
     x.rs=rc.rs;
     int sum=rc.ls-lc.rs;
     if(sum>) x.ls+=sum;
     else x.rs+=-sum;
     // x.ls=maxx(0,lc.ls+rc.ls-lc.rs);
     // x.rs=maxx(0,rc.rs+lc.rs-rc.ls);
     return x;
 }

 int bt(int l,int r)
 {
     int x=++tl;
     t[x].l=l;t[x].r=r;
     t[x].lc=t[x].rc=;
     t[x].ls=t[x].rs=;
     if(l<r)
     {
         int mid=(l+r)/;
         t[x].lc=bt(l,mid);
         t[x].rc=bt(mid+,r);
         int lc=t[x].lc,rc=t[x].rc;
         t[x]=upd(t[x],t[lc],t[rc]);
     }
     else
     {
         if(s[l]==')') t[x].ls=;
         else t[x].rs=;
     }
     return x;
 }

 void change(int x,int p)
 {
     if(t[x].l==t[x].r) {swap(t[x].ls,t[x].rs);return ;}
     int lc=t[x].lc,rc=t[x].rc,mid=(t[x].l+t[x].r)/;
     if(p<=mid) change(lc,p);
     else change(rc,p);
     t[x]=upd(t[x],t[lc],t[rc]);
 }

 void query(int x,int l,int r)
 {
     if(t[x].l==l && t[x].r==r) {c[++cl]=x;return;}
     int lc=t[x].lc,rc=t[x].rc,mid=(t[x].l+t[x].r)/;
     if(r<=mid) query(lc,l,r);
     else if(l>mid) query(rc,l,r);
     else
     {
         query(lc,l,mid);
         query(rc,mid+,r);
     }
 }

 int fd(int x,int k,int tmp)
 {
     if(t[x].l==t[x].r) return t[x].l;
     int lc=t[x].lc,rc=t[x].rc;
     if(tmp==)
     {
         if(t[lc].ls>=k) return fd(lc,k,tmp);
         return fd(rc,k-t[lc].ls+t[lc].rs,tmp);
     }
     else
     {
         if(t[rc].rs>=k) return fd(rc,k,tmp);
         return fd(lc,k-t[rc].rs+t[rc].ls,tmp);
     }
 }

 int main()
 {
     freopen("a.in","r",stdin);
     freopen("a.out","w",stdout);
     int T;
     scanf("%d",&T);
     while(T--)
     {
         scanf("%d%d",&n,&m);
         scanf("%s",s+);
         tl=;bt(,n);
         for(int i=;i<=m;i++)
         {
             int tmp,x,l,r,k,ans;
             scanf("%d",&tmp);
             if(tmp==)
             {
                 scanf("%d",&x);
                 change(,x);
             }
             else
             {
                 scanf("%d%d%d",&l,&r,&k);
                 cl=;query(,l,r);
                 node now=t[c[]];
                 for(int j=;j<=cl;j++) now=upd(now,now,t[c[j]]);
                 if(now.ls+now.rs<k) {printf("-1\n");continue;}
                 if(now.ls>=k)
                 {
                     node p0=t[c[]],p1;
                     if(p0.ls>=k) ans=fd(c[],k,);
                     else
                     {
                         for(int j=;j<=cl;j++)
                         {
                             p1=upd(p1,p0,t[c[j]]);
                             if(p1.ls>=k)
                             {
                                 ans=fd(c[j],k-p0.ls+p0.rs,);
                                 break;
                             }
                             p0=p1;
                         }
                     }
                 }
                 else
                 {
                     k=now.ls+now.rs-k+;
                     node p0=t[c[cl]],p1;
                     if(p0.rs>=k) ans=fd(c[cl],k,);
                     else
                     {
                         for(int j=cl-;j>=;j--)
                         {
                             p1=upd(p1,t[c[j]],p0);
                             if(p1.rs>=k) {ans=fd(c[j],k-p0.rs+p0.ls,);break;}
                             p0=p1;
                         }
                     }
                 }
                 printf("%d\n",ans);
             }
         }
     }
     return ;
 }