【BZOJ2209】括号序列（JSOI2011）-Splay

测试地址：括号序列
做法：本题需要用到Splay。
对于任意一个括号序列，我们把配对的括号删掉之后，最后肯定是x$x$个右括号紧接着y$y$个左括号的形式，那么怎么样才能用最少的次数改正呢？首先显然x+y$x+y$是偶数，如果x$x$和y$y$都是偶数，那么最少次数显然为x/2+y/2$x/2+y/2$；如果x$x$和y$y$都是奇数，那么最少次数为x/2+y/2+2$x/2+y/2+2$。上面两个式子等价于：⌊(x+1)/2⌋+⌊(y+1)/2⌋$\lfloor (x+1)/2\rfloor +\lfloor (y+1)/2\rfloor$，那么我们只需要知道x$x$和y$y$，就可以完成这个操作了。
但我们要怎么知道x$x$和y$y$呢？若把左括号看成1$1$，右括号看成−1$-1$，x$x$就等于区间左端最小和的相反数，y$y$等于区间右端的最大和。这个应该很容易证明，就以求x$x$为例，在往右不断加值的过程中，在最后一个多余的右括号之后再也没有多余的右括号了，所以后面的值肯定都大于这个节点，而对于左边，左边区间中的多余的右括号之和不可能大于总区间中的多余的右括号数，所以左边的值肯定都大于这个节点，因此最后一个多余的右括号就是左端最小和所在的节点。
那么我们就用一个Splay来维护区间反转和翻转，由于这两个操作执行的顺序不同对结果没有影响，因此不用特殊处理。因为有区间反转的操作，所以我们还要维护左端的最大和和右端的最小和。又因为要维护这些个东西，所以区间和我们也要维护。这样我们就解决了这一题。
以下是本人代码：

#include <bits/stdc++.h>
using namespace std;
int n,m,rt=1,tot=2;
int lmax[100010]={0},lmin[100010]={0},rmax[100010]={0},rmin[100010]={0},sum[100010]={0};
int ch[100010][2]={0},siz[100010]={0},fa[100010]={0},val[100010]={0};
bool rev[100010]={0},inv[100010]={0};
char s[100010];

void inverse_point(int x)
{
    inv[x]=!inv[x];
    sum[x]=-sum[x];
    val[x]=-val[x];
    swap(lmax[x],lmin[x]);
    lmax[x]=-lmax[x],lmin[x]=-lmin[x];
    swap(rmax[x],rmin[x]);
    rmax[x]=-rmax[x],rmin[x]=-rmin[x];
}

void reverse_point(int x)
{
    rev[x]=!rev[x];
    swap(lmax[x],rmax[x]);
    swap(lmin[x],rmin[x]);
}

void pushdown(int x)
{
    int lc=ch[x][0],rc=ch[x][1];
    if (rev[x])
    {
        reverse_point(lc),reverse_point(rc);
        swap(ch[x][0],ch[x][1]);
        rev[x]=0;
    }
    if (inv[x])
    {
        inverse_point(lc),inverse_point(rc);
        inv[x]=0;
    }
}

void pushup(int x)
{
    int lc=ch[x][0],rc=ch[x][1];
    siz[x]=siz[lc]+siz[rc]+1;
    sum[x]=sum[lc]+sum[rc]+val[x];
    lmax[x]=max(lmax[lc],sum[lc]+val[x]+lmax[rc]);
    lmin[x]=min(lmin[lc],sum[lc]+val[x]+lmin[rc]);
    rmax[x]=max(rmax[rc],sum[rc]+val[x]+rmax[lc]);
    rmin[x]=min(rmin[rc],sum[rc]+val[x]+rmin[lc]);
}

void Push(int x)
{
    if (fa[x]) Push(fa[x]);
    pushdown(x);
}

void rotate(int x,bool f)
{
    int y=fa[x];
    pushdown(x);
    ch[y][!f]=ch[x][f];
    fa[ch[x][f]]=y;
    if (fa[y]) ch[fa[y]][ch[fa[y]][1]==y]=x;
    fa[x]=fa[y];
    fa[y]=x;
    ch[x][f]=y;
    pushup(y),pushup(x);
}

void Splay(int x,int goal)
{
    Push(x);
    while(fa[x]!=goal)
    {
        if (fa[fa[x]]==goal) rotate(x,ch[fa[x]][0]==x);
        else
        {
            int y=fa[x],z=fa[fa[x]];
            bool f=(ch[y][1]==x);
            if (ch[z][f]==y) rotate(y,!f),rotate(x,!f);
            else rotate(x,!f),rotate(x,f);
        }
    }
    pushup(x);
    if (!goal) rt=x;
}

void build(int &v,int l,int r,int f)
{
    int mid=(l+r)>>1;
    if (l>r) return;
    if (!v) v=++tot;
    val[v]=(s[mid]=='(')?1:-1;
    fa[v]=f;
    if (l==r)
    {
        siz[v]=1;
        sum[v]=val[v];
        if (val[v]>0) lmax[v]=rmax[v]=1;
        else lmin[v]=rmin[v]=-1;
        return;
    }
    build(ch[v][0],l,mid-1,v);
    build(ch[v][1],mid+1,r,v);
    pushup(v);
}

void rotate_to(int k,int goal)
{
    int x=rt;
    pushdown(x);
    while(siz[ch[x][0]]+1!=k)
    {
        int s=siz[ch[x][0]]+1;
        if (s>k) x=ch[x][0];
        else k-=s,x=ch[x][1];
        pushdown(x);
    }
    Splay(x,goal);
}

void turn_up(int l,int r)
{
    rotate_to(l,0);
    rotate_to(r+2,rt);
}

int query(int l,int r)
{
    int x,y,g;
    turn_up(l,r);
    g=ch[ch[rt][1]][0];
    x=-lmin[g],y=rmax[g];
    return (x+1)/2+(y+1)/2;
}

void inverse(int l,int r)
{
    turn_up(l,r);
    inverse_point(ch[ch[rt][1]][0]);
    pushup(ch[rt][1]),pushup(rt);
}

void reverse(int l,int r)
{
    turn_up(l,r);
    reverse_point(ch[ch[rt][1]][0]);
    pushup(ch[rt][1]),pushup(rt);
}

int main()
{
    scanf("%d%d",&n,&m);
    scanf("%s",s+1);

    siz[1]=2,ch[1][1]=2;
    fa[2]=1,siz[2]=1;
    build(ch[2][0],1,n,2);
    pushup(2),pushup(1);

    for(int i=1;i<=m;i++)
    {
        int op,l,r,x,y;
        scanf("%d%d%d",&op,&l,&r);
        if (op==0) printf("%d\n",query(l,r));
        if (op==1) inverse(l,r);
        if (op==2) reverse(l,r);
    }

    return 0;
}