翻转括号序列(线段树 + 二分)

传送门

题面

思路

• 操作一把括号改变

我们令( = 1,) = -1，那不就是变成了区间乘以-1即可；

• 查询最右边的合法’)’

首先考虑最暴力的思路，就硬for，暴力查询$[L,i]$的和，看看是否为0，这肯定是TLE的；

那么我们考虑优化；

我们考虑维护一个前缀最小值lmn；

然后用二分找区间$[L,n]$最后一个lmn >= 0的点r1；

这样$[L,r1]$的lmn≥0，且是r1是最大的，且这里面可能存在解；

我们是要找某个最大的点R，使得$[L,R{]}_{sum}=0$

这一次二分区间$[L,r1]$找答案即可（二分答案的思路）；

Code

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 1e6 + 10;

int n,m;
int a[N];
#define lc (p << 1)
#define rc (p << 1 | 1)
struct Node{
    int l,r,sum;
    int lmn,lmx;
    bool neg = 0;//是否乘上-1
}tr[N<<2];
void push_up(Node&rt,Node ls,Node rs){
    rt.sum = ls.sum + rs.sum;
    rt.lmn = min(ls.lmn,ls.sum + rs.lmn);
    rt.lmx = max(ls.lmx,ls.sum + rs.lmx);
}
void push_up(int p){
    push_up(tr[p],tr[lc],tr[rc]);
}
void build(int p,int l,int r){
    tr[p].l = l,tr[p].r = r;
    tr[p].neg = 0;
    if(l == r){
        tr[p].lmn = tr[p].lmx = tr[p].sum = a[l];
        return;
    }
    int mid = (l + r) >> 1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    push_up(p);
}
void node_neg(int x){
    tr[x].neg ^= 1;
    tr[x].lmn *= -1,tr[x].lmx *= -1;
    tr[x].sum *= -1;
    swap(tr[x].lmn,tr[x].lmx);
}
void push_down(int p){
    if(tr[p].neg){
        tr[p].neg = 0;
        node_neg(lc);
        node_neg(rc);
    }
}
//给区间[l,r] * -1;
void cover(int p,int l,int r){
    if(tr[p].l >= l && tr[p].r <= r){
        node_neg(p);
        return;
    }
    push_down(p);
    int mid = (tr[p].l + tr[p].r) >> 1;
    if(r <= mid) cover(lc,l,r);
    else if(l > mid) cover(rc,l,r);
    else{
        cover(lc,l,mid);
        cover(rc,mid+1,r);
    }
    push_up(p);
}
//覆盖区间[l,r]的Node
Node query(int p,int l,int r){
    if(tr[p].l >= l && tr[p].r <= r){
        return tr[p];
    }
    push_down(p);
    int mid = (tr[p].l + tr[p].r) >> 1;
    if(r <= mid) return query(lc,l,r);
    else if(l > mid) return query(rc,l,r);
    else{
        Node rt;
        rt.l = l,rt.r = r;
        Node ls = query(lc,l,mid);
        Node rs = query(rc,mid+1,r);
        push_up(rt,ls,rs);
        return rt;
    }
}
int get_R(int L){
    //查找最大的区间[L,r1];
    int l1 = L,r1 = n;
    while(l1 < r1){
        int mid = (1 + l1 + r1) >> 1;
        if(query(1,L,mid).lmn >= 0) l1 = mid;
        else r1 = mid - 1;
    }
    //l1 == r1
    //在区间[L,r1]中查找最大的右端点R
    int l2 = L,r2 = r1;
    while(l2 < r2){
        int mid = (l2 + r2 + 1) >> 1;
        Node t1 = query(1,L,mid);
        Node t2;
        t2.lmn = 0,t2.sum = 0;
        if(mid+1 <= r2) t2 = query(1,mid+1,r1);
        if(t1.sum == 0 || t1.sum + t2.lmn == 0) l2 = mid;
        else r2 = mid - 1;
    }
    //l2 == r2
    int R = r2;
    if(L == R) R = 0;
    return R;
}
void solve(){
    cin >> n >> m;
    for(int i=1;i<=n;++i){
        char ch;
        cin >> ch;
        if(ch == '(') a[i] = 1;
        else a[i] = -1;
    }
    build(1,1,n);
    int opt,l,r;
    while(m--){
        cin >> opt;
        if(opt == 1){
            cin >> l >> r;
            cover(1,l,r);
        }
        else{
            cin >> l;
            cout << get_R(l) << '\n';
        }
    }
}

signed main(){
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    solve();
    return 0;
}

参考

大佬的博客