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=300000;
struct trnt{
    int ch[2];
    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=1;
    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,0);
    tr[spc].mnp=tr[spc].mns=std::min(0,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^=1;
    return ;
}
void anti(int spc)
{
    if(!spc)
        return ;
    tr[spc].val*=-1;
    tr[spc].sum*=-1;
    tr[spc].mxp*=-1;
    tr[spc].mnp*=-1;
    tr[spc].mxs*=-1;
    tr[spc].mns*=-1;
    std::swap(tr[spc].mxp,tr[spc].mnp);
    std::swap(tr[spc].mxs,tr[spc].mns);
    tr[spc].ant^=1;
    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==1)
    {
        tr[spc].mnp=0;
        tr[spc].mns=0;
        tr[spc].mxp=v*tr[spc].wgt;
        tr[spc].mxs=v*tr[spc].wgt;
    }else{
        tr[spc].mxp=0;
        tr[spc].mxs=0;
        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=0;
    }
    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)>>1;
    spc=++siz;
    tr[spc].val=num[mid];
    tr[spc].fa=f;
    Build(l,mid-1,lll,spc);
    Build(mid+1,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+1==k)
        return spc;
    return plc(rrr,k-tr[lll].wgt-1);
}
void rush(int l,int r)
{
    l=plc(root,l);
    r=plc(root,r+2);
    splay(l,0);
    splay(r,root);
    return ;
}
int main()
{
    scanf("%d%d",&n,&m);
    scanf("%s",cmd+1);
    for(int i=1;i<=n;i++)
        num[i]=((cmd[i]==')')<<1)-1;
    Build(0,n+1,root,0);
    while(m--)
    {
        int l,r;
        scanf("%s",cmd+1);
        scanf("%d%d",&l,&r);
        rush(l,r);
        if(cmd[1]=='R')
        {
            scanf("%s",cmd+1);
            chg(tr[tr[root].rs].ls,((cmd[1]==')')<<1)-1);
        }else if(cmd[1]=='S')
            trr(tr[tr[root].rs].ls);
        else if(cmd[1]=='I')
            anti(tr[tr[root].rs].ls);
        else{
            int spc=tr[tr[root].rs].ls;
            printf("%d
",(tr[spc].mxp+1)/2+(-tr[spc].mns+1)/2);
        }
        pushup(tr[root].rs);
        pushup(root);
    }
    return 0;
}