BZOJ2329: [HNOI2011]括号修复(Splay)

解题思路:

Replace、Swap、Invert都可以使用Splay完美解决（只需要解决一下标记冲突就好了）。

最后只需要统计左右括号冲突就好了。

相当于动态统计最大前缀合和最小后缀和。

因为支持翻转反转操作，翻转标记或取反就好了。

代码：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define lll tr[spc].ch[0]
 #define rrr tr[spc].ch[1]
 #define ls ch[0]
 #define rs ch[1]
 typedef long long lnt;
 const int N=;
 struct trnt{
     int ch[];
     int fa;
     int wgt;
     int val;
     int sum;
     int mxp;
     int mnp;
     int mxs;
     int mns;
     int lzt;
     bool rev;
     bool ant;
 }tr[N];
 int n,m;
 int siz;
 int root;
 int num[N];
 char cmd[N];
 bool whc(int spc)
 {
     return tr[tr[spc].fa].rs==spc;
 }
 void pushup(int spc)
 {
     tr[spc].wgt=;
     if(lll)
         tr[spc].wgt+=tr[lll].wgt;
     if(rrr)
         tr[spc].wgt+=tr[rrr].wgt;
     tr[spc].sum=tr[spc].val;
     if(lll)
         tr[spc].sum+=tr[lll].sum;
     if(rrr)
         tr[spc].sum+=tr[rrr].sum;
     tr[spc].mxp=tr[spc].mxs=std::max(tr[spc].sum,);
     tr[spc].mnp=tr[spc].mns=std::min(,tr[spc].sum);
     if(lll)
     {
         tr[spc].mxp=std::max(tr[spc].mxp,std::max(tr[lll].mxp,tr[lll].sum+tr[spc].val));
         tr[spc].mnp=std::min(tr[spc].mnp,std::min(tr[lll].mnp,tr[lll].sum+tr[spc].val));
         tr[spc].mxs=std::max(tr[spc].mxs,std::max(tr[rrr].sum+tr[spc].val,tr[spc].val+tr[lll].mxs+tr[rrr].sum));
         tr[spc].mns=std::min(tr[spc].mns,std::min(tr[rrr].sum+tr[spc].val,tr[spc].val+tr[lll].mns+tr[rrr].sum));
     }
     if(rrr)
     {
         tr[spc].mxs=std::max(tr[spc].mxs,std::max(tr[rrr].mxs,tr[rrr].sum+tr[spc].val));
         tr[spc].mns=std::min(tr[spc].mns,std::min(tr[rrr].mns,tr[rrr].sum+tr[spc].val));
         tr[spc].mxp=std::max(tr[spc].mxp,std::max(tr[lll].sum+tr[spc].val,tr[spc].val+tr[lll].sum+tr[rrr].mxp));
         tr[spc].mnp=std::min(tr[spc].mnp,std::min(tr[lll].sum+tr[spc].val,tr[spc].val+tr[lll].sum+tr[rrr].mnp));
     }
     return ;
 }
 void trr(int spc)
 {
     if(!spc)
         return ;
     std::swap(lll,rrr);
     std::swap(tr[spc].mxp,tr[spc].mxs);
     std::swap(tr[spc].mnp,tr[spc].mns);
     tr[spc].rev^=;
     return ;
 }
 void anti(int spc)
 {
     if(!spc)
         return ;
     tr[spc].val*=-;
     tr[spc].sum*=-;
     tr[spc].mxp*=-;
     tr[spc].mnp*=-;
     tr[spc].mxs*=-;
     tr[spc].mns*=-;
     std::swap(tr[spc].mxp,tr[spc].mnp);
     std::swap(tr[spc].mxs,tr[spc].mns);
     tr[spc].ant^=;
     return ;
 }
 void chg(int spc,int v)
 {
     if(!spc)
         return ;
     tr[spc].ant=false;
     tr[spc].val=v;
     tr[spc].lzt=v;
     tr[spc].sum=v*tr[spc].wgt;
     if(v==)
     {
         tr[spc].mnp=;
         tr[spc].mns=;
         tr[spc].mxp=v*tr[spc].wgt;
         tr[spc].mxs=v*tr[spc].wgt;
     }else{
         tr[spc].mxp=;
         tr[spc].mxs=;
         tr[spc].mnp=v*tr[spc].wgt;
         tr[spc].mns=v*tr[spc].wgt;
     }
     return ;
 }
 void pushdown(int spc)
 {
     if(tr[spc].rev)
     {
         trr(lll);
         trr(rrr);
         tr[spc].rev=false;
     }
     if(tr[spc].lzt)
     {
         chg(lll,tr[spc].lzt);
         chg(rrr,tr[spc].lzt);
         tr[spc].lzt=;
     }
     if(tr[spc].ant)
     {
         anti(lll);
         anti(rrr);
         tr[spc].ant=false;
     }
     return ;
 }
 void recal(int spc)
 {
     if(tr[spc].fa)
         recal(tr[spc].fa);
     pushdown(spc);
     return ;
 }
 void rotate(int spc)
 {
     int f=tr[spc].fa;
     bool k=whc(spc);
     tr[f].ch[k]=tr[spc].ch[!k];
     tr[spc].ch[!k]=f;
     tr[tr[f].fa].ch[whc(f)]=spc;
     tr[spc].fa=tr[f].fa;
     tr[f].fa=spc;
     tr[tr[f].ch[k]].fa=f;
     pushup(f);
     pushup(spc);
     return ;
 }
 void splay(int spc,int f)
 {
     recal(spc);
     while(tr[spc].fa!=f)
     {
         int ft=tr[spc].fa;
         if(tr[ft].fa==f)
         {
             rotate(spc);
             break;
         }
         if(whc(spc)^whc(ft))
             rotate(spc);
         else
             rotate(ft);
         rotate(spc);
     }
     if(!f)
         root=spc;
     return ;
 }
 void Build(int l,int r,int &spc,int f)
 {
     if(l>r)
         return ;
     int mid=(l+r)>>;
     spc=++siz;
     tr[spc].val=num[mid];
     tr[spc].fa=f;
     Build(l,mid-,lll,spc);
     Build(mid+,r,rrr,spc);
     pushup(spc);
     return ;
 }
 int plc(int spc,int k)
 {
     pushdown(spc);
     if(tr[lll].wgt>=k)
         return plc(lll,k);
     if(tr[lll].wgt+==k)
         return spc;
     return plc(rrr,k-tr[lll].wgt-);
 }
 void rush(int l,int r)
 {
     l=plc(root,l);
     r=plc(root,r+);
     splay(l,);
     splay(r,root);
     return ;
 }
 int main()
 {
     scanf("%d%d",&n,&m);
     scanf("%s",cmd+);
     for(int i=;i<=n;i++)
         num[i]=((cmd[i]==')')<<)-;
     Build(,n+,root,);
     while(m--)
     {
         int l,r;
         scanf("%s",cmd+);
         scanf("%d%d",&l,&r);
         rush(l,r);
         if(cmd[]=='R')
         {
             scanf("%s",cmd+);
             chg(tr[tr[root].rs].ls,((cmd[]==')')<<)-);
         }else if(cmd[]=='S')
             trr(tr[tr[root].rs].ls);
         else if(cmd[]=='I')
             anti(tr[tr[root].rs].ls);
         else{
             int spc=tr[tr[root].rs].ls;
             printf("%d\n",(tr[spc].mxp+)/+(-tr[spc].mns+)/);
         }
         pushup(tr[root].rs);
         pushup(root);
     }
     return ;
 }