(splay)版代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;
 
const int maxn=1e5+5;
 
int n,m;
int a[maxn];
char s[maxn],ch[10];
 
int read() {
    int x=0,f=1;char ch=getchar();
    for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
    for(;ch>='0'&&ch<='9';ch=getchar())x=x*10+ch-'0';
    return x*f;
}
 
struct Splay {
    int tot,root;
    int cov[maxn];
    bool rev[maxn],Int[maxn];
    int son[maxn][2],fa[maxn];
    int siz[maxn],val[maxn],sum[maxn];
    int lmx[maxn],lmn[maxn],rmx[maxn],rmn[maxn];
 
    void update(int u) {
        siz[u]=siz[son[u][0]]+1+siz[son[u][1]];
        sum[u]=sum[son[u][0]]+val[u]+sum[son[u][1]];
        lmx[u]=max(lmx[son[u][0]],sum[son[u][0]]+val[u]+lmx[son[u][1]]);
        lmn[u]=min(lmn[son[u][0]],sum[son[u][0]]+val[u]+lmn[son[u][1]]);
        rmx[u]=max(rmx[son[u][1]],sum[son[u][1]]+val[u]+rmx[son[u][0]]);
        rmn[u]=min(rmn[son[u][1]],sum[son[u][1]]+val[u]+rmn[son[u][0]]);
    }
 
    void build(int l,int r,int lst) {
        if(r<l)return;
        if(l==r) {
            siz[l]=1,val[l]=sum[l]=a[l];
            fa[l]=lst,son[lst][l>lst]=l;
            lmx[l]=max(0,a[l]),lmn[l]=min(0,a[l]);
            rmx[l]=max(0,a[l]),rmn[l]=min(0,a[l]);
            return;
        }
        int mid=(l+r)>>1;
        val[mid]=a[mid],fa[mid]=lst;
        son[lst][mid>lst]=mid;
        build(l,mid-1,mid),build(mid+1,r,mid);
        update(mid);
    }
     
    void prepare() {
        tot=n+2;build(1,n+2,0);root=(n+3)>>1;
    }
 
    void add_rev_tag(int p) {
        if(!p)return;
        rev[p]^=1,swap(son[p][0],son[p][1]);
        swap(lmx[p],rmx[p]),swap(lmn[p],rmn[p]);
    }
 
    void add_cov_tag(int p,int v) {
        if(!p)return;
        val[p]=v,sum[p]=siz[p]*v,cov[p]=v,Int[p]=0;
        if(v==1)lmx[p]=rmx[p]=siz[p],lmn[p]=rmn[p]=0;
        else lmn[p]=rmn[p]=-siz[p],lmx[p]=rmx[p]=0;
    }
 
    void add_Int_tag(int p) {
        if(!p)return;
        Int[p]^=1,sum[p]=0-sum[p];
        if(val[p]==1)val[p]=-1;else val[p]=1;
        swap(lmx[p],lmn[p]),swap(rmx[p],rmn[p]);
        lmx[p]*=-1,lmn[p]*=-1,rmx[p]*=-1,rmn[p]*=-1;
    }
 
    void push_down(int u) {
        if(cov[u]) {
            add_cov_tag(son[u][0],cov[u]);
            add_cov_tag(son[u][1],cov[u]);
            cov[u]=0;
        }
        if(Int[u]) {
            add_Int_tag(son[u][0]);
            add_Int_tag(son[u][1]);
            Int[u]=0;
        }
        if(rev[u]) {
            add_rev_tag(son[u][0]);
            add_rev_tag(son[u][1]);
            rev[u]=0;
        }
    }
 
    int find(int u,int rk) {
        push_down(u);
        if(siz[son[u][0]]+1==rk)return u;
        if(siz[son[u][0]]>=rk)return find(son[u][0],rk);
        return find(son[u][1],rk-siz[son[u][0]]-1);
    }
 
    int t(int u) {
        return son[fa[u]][1]==u;
    }
 
    void rotate(int u) {
        int ret=t(u),f=fa[u],s=son[u][ret^1];
        son[f][ret]=s;if(s)fa[s]=f;son[u][ret^1]=f;
        fa[u]=fa[f];if(fa[f])son[fa[f]][t(f)]=u;
        fa[f]=u,update(f),update(u);
    }
 
    void splay(int goal,int u) {
        int tmp=fa[goal];
        while(fa[u]!=tmp) {
            if(fa[fa[u]]!=tmp) {
                if(t(fa[u])==t(u))rotate(fa[u]);
                else rotate(u);
            }rotate(u);
        }
        if(!tmp)root=u;
    }
 
    void cover(int l,int r,int v) {
        int u1=find(root,l-1),u2=find(root,r+1);
        splay(root,u1),splay(son[u1][1],u2);
        add_cov_tag(son[u2][0],v);
        update(u2),update(u1);
    }
 
    void rever(int l,int r) {
        int u1=find(root,l-1),u2=find(root,r+1);
        splay(root,u1),splay(son[u1][1],u2);
        add_rev_tag(son[u2][0]);
        update(u2),update(u1);
    }
 
    void invert(int l,int r) {
        int u1=find(root,l-1),u2=find(root,r+1);
        splay(root,u1),splay(son[u1][1],u2);
        add_Int_tag(son[u2][0]);
        update(u2),update(u1);
    }
 
    int query(int l,int r) {
        int u1=find(root,l-1),u2=find(root,r+1);
        splay(root,u1),splay(son[u1][1],u2);
        int u=son[u2][0],tmp=((0-lmn[u])+1)/2+(rmx[u]+1)/2;
        return tmp;
    }
}T;
 
int main() {
    n=read(),m=read();
    scanf("%s",s+2);
    for(int i=2;i<=n+1;i++)
        if(s[i]=='(')a[i]=1;
        else a[i]=-1;
    T.prepare();
    for(int i=1;i<=m;i++) {
        scanf("%s",s+1);
        int l=read()+1,r=read()+1;
        if(s[1]=='R') {
            scanf("%s",ch+1);
            if(ch[1]=='(')T.cover(l,r,1);
            else T.cover(l,r,-1);
        }
        if(s[1]=='S')T.rever(l,r);
        if(s[1]=='I')T.invert(l,r);
        if(s[1]=='Q')printf("%d
",T.query(l,r));
    }
    return 0;
}

(fhq)_(treap)版代码如下：

#include <ctime>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef pair<int,int> pii;
 
const int maxn=1e5+5;
 
int n,m;
int a[maxn];
char s[maxn],ch[5];
 
int read() {
    int x=0,f=1;char ch=getchar();
    for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
    for(;ch>='0'&&ch<='9';ch=getchar())x=x*10+ch-'0';
    return x*f;
}
 
struct fhq_treap {
    int tot,root;
    int cov[maxn];
    bool rev[maxn],Int[maxn];
    int son[maxn][2],fix[maxn];
    int siz[maxn],val[maxn],sum[maxn];
    int lmx[maxn],lmn[maxn],rmx[maxn],rmn[maxn];
 
    void update(int p) {
        siz[p]=siz[son[p][0]]+1+siz[son[p][1]];
        sum[p]=sum[son[p][0]]+val[p]+sum[son[p][1]];
        lmx[p]=max(lmx[son[p][0]],sum[son[p][0]]+val[p]+lmx[son[p][1]]);
        lmn[p]=min(lmn[son[p][0]],sum[son[p][0]]+val[p]+lmn[son[p][1]]);
        rmx[p]=max(rmx[son[p][1]],sum[son[p][1]]+val[p]+rmx[son[p][0]]);
        rmn[p]=min(rmn[son[p][1]],sum[son[p][1]]+val[p]+rmn[son[p][0]]);
    }
 
    void build(int l,int r,int lst) {
        if(r<l)return;
        if(l==r) {
            siz[l]=1,fix[l]=rand();
            son[lst][l>lst]=l;
            val[l]=sum[l]=a[l];
            lmx[l]=max(0,a[l]),lmn[l]=min(0,a[l]);
            rmx[l]=max(0,a[l]),rmn[l]=min(0,a[l]);
            return;
        }
        int mid=(l+r)>>1;
        fix[mid]=rand(),val[mid]=a[mid];
        son[lst][mid>lst]=mid;
        build(l,mid-1,mid);build(mid+1,r,mid);
        update(mid);
    }
 
    void prepare() {
        tot=n;build(1,n,0);root=(n+1)>>1;
    }
 
    void add_cov_tag(int u,int v) {
        if(!u)return;
        val[u]=v,sum[u]=siz[u]*v,cov[u]=v,Int[u]=0;
        if(v==1)lmx[u]=rmx[u]=siz[u],lmn[u]=rmn[u]=0;
        else lmn[u]=rmn[u]=-siz[u],lmx[u]=rmx[u]=0;
    }
 
    void add_Int_tag(int u) {
        if(!u)return;
        Int[u]^=1,sum[u]=-sum[u];
        if(val[u]==1)val[u]=-1;else val[u]=1;
        swap(lmn[u],lmx[u]),swap(rmx[u],rmn[u]);
        lmn[u]*=-1,lmx[u]*=-1,rmx[u]*=-1,rmn[u]*=-1;
    }
 
    void add_rev_tag(int u) {
        if(!u)return;
        rev[u]^=1,swap(son[u][0],son[u][1]);
        swap(lmx[u],rmx[u]),swap(lmn[u],rmn[u]);
    }
 
    void push_down(int u) {
        if(cov[u]) {
            add_cov_tag(son[u][0],cov[u]);
            add_cov_tag(son[u][1],cov[u]);
            cov[u]=0;
        }
        if(Int[u]) {
            add_Int_tag(son[u][0]);
            add_Int_tag(son[u][1]);
            Int[u]=0;
        }
        if(rev[u]) {
            add_rev_tag(son[u][0]);
            add_rev_tag(son[u][1]);
            rev[u]=0;
        }
    }
 
    pii split(int u,int rk) {
        if(!rk)return make_pair(0,u);
        if(rk==siz[u])return make_pair(u,0);
        push_down(u);
        if(siz[son[u][0]]>=rk) {
            pii tmp=split(son[u][0],rk);
            son[u][0]=tmp.second,update(u);
            return make_pair(tmp.first,u);
        }
        else {
            pii tmp=split(son[u][1],rk-siz[son[u][0]]-1);
            son[u][1]=tmp.first,update(u);
            return make_pair(u,tmp.second);
        }
    }
 
    int merge(int a,int b) {
        if(!a||!b)return a+b;
        push_down(a),push_down(b);
        if(fix[a]>fix[b])return son[a][1]=merge(son[a][1],b),update(a),a;
        else return son[b][0]=merge(a,son[b][0]),update(b),b;
    }
 
    void cover(int l,int r,int v) {
        pii tmp1=split(root,r);
        pii tmp2=split(tmp1.first,l-1);
        add_cov_tag(tmp2.second,v);
        root=merge(merge(tmp2.first,tmp2.second),tmp1.second);
    }
 
    void rever(int l,int r) {
        pii tmp1=split(root,r);
        pii tmp2=split(tmp1.first,l-1);
        add_rev_tag(tmp2.second);
        root=merge(merge(tmp2.first,tmp2.second),tmp1.second);
    }
 
    void invert(int l,int r) {
        pii tmp1=split(root,r);
        pii tmp2=split(tmp1.first,l-1);
        add_Int_tag(tmp2.second);
        root=merge(merge(tmp2.first,tmp2.second),tmp1.second);
    }
 
    int query(int l,int r) {
        pii tmp1=split(root,r);
        pii tmp2=split(tmp1.first,l-1);
        int u=tmp2.second,tmp=((0-lmn[u])+1)/2+(rmx[u]+1)/2;
        root=merge(merge(tmp2.first,tmp2.second),tmp1.second);
        return tmp;
    }
}T;
 
int main() {
    n=read(),m=read();
    scanf("%s",s+1);
    for(int i=1;i<=n;i++)
        if(s[i]=='(')a[i]=1;
        else a[i]=-1;
    T.prepare();
    for(int i=1;i<=m;i++) {
        scanf("%s",s+1);
        int l=read(),r=read();
        if(s[1]=='R') {
            scanf("%s",ch+1);
            if(ch[1]=='(')T.cover(l,r,1);
            else T.cover(l,r,-1);
        }
        if(s[1]=='S')T.rever(l,r);
        if(s[1]=='I')T.invert(l,r);
        if(s[1]=='Q')printf("%d
",T.query(l,r));
    }
    return 0;
}