BZOJ2329 [HNOI2011]括号修复

把左括号看做$1$，右括号看做$-1$，于是查询操作等于查询一个区间左边右边最大(最小)子段和

支持区间翻转，反转，覆盖操作。。。注意如果有覆盖操作，之前的操作全部作废了。。。于是在下传标记的时候要最后做。。。

 

/**************************************************************
    Problem: 2329
    User: rausen
    Language: C++
    Result: Accepted
    Time:4252 ms
    Memory:7352 kb
****************************************************************/
 
#include <cstdio>
#include <algorithm>
 
#define _max(x, y) (x > y ? x : y)
#define _min(x, y) (x < y ? x : y)
using namespace std;
const int N = 1e5 + 5;
 
int read();
int get_c();
int get_op();
 
namespace treap {
    struct node;
    node *root, *null;
     
    struct node {
        node *ls, *rs;
        int val, rev, inv, fill, maxl, maxr, minl, minr, sum, sz;
         
        #define Len (1 << 16)
        inline void* operator new(size_t, int _v = 0) { 
            static node *mempool, *c;
            if (mempool == c)
                mempool = (c = new node[Len]) + Len;
            c -> ls = c -> rs = null;
            c -> val = c -> sum = _v, c -> rev = c -> inv = c -> fill = 0;
            c -> maxl = c -> maxr =  c -> minl = c -> minr = 0;
            c -> sz = 1;
            return c++;
        }
        #undef Len
                 
        inline void reverse() {
            rev ^= 1;
            swap(ls, rs);
            swap(minl, minr), swap(maxl, maxr);
        }
        inline void inverse() {
            inv ^= 1;
            fill = -fill, val = -val, sum = -sum;
            swap(maxl, minl), maxl = -maxl, minl = -minl;
            swap(maxr, minr), maxr = -maxr, minr = -minr;
        }
        inline void replace(int t) {
            fill = val = t, sum = sz * t;
            maxl = maxr = sz * (t == 1);
            minl = minr = -sz * (t == -1);
        }
 
        inline node* update() {
            sz = ls -> sz + rs -> sz + 1;
            sum = ls -> sum + rs -> sum + val;
            maxl = _max(ls -> maxl, ls -> sum + val + _max(0, rs -> maxl));
            minl = _min(ls -> minl, ls -> sum + val + _min(0, rs -> minl));
            maxr = _max(rs -> maxr, rs -> sum + val + _max(0, ls -> maxr));
            minr = _min(rs -> minr, rs -> sum + val + _min(0, ls -> minr));
            return this;
        }
        inline node* push() {
            if (rev) {
                ls -> reverse(), rs -> reverse();
                rev = 0;
            }
            if (inv) {
                ls -> inverse(), rs -> inverse();
                inv = 0; 
            }
            if (fill) {
                ls -> replace(fill), rs -> replace(fill);
                fill = 0;
            }
            return this;
        }
    };
     
    inline void init() {
        null = new()node;
        null -> ls = null -> rs = null;   
        null -> sz = null -> val = 0;
    }
     
    inline unsigned int Rand() {
        static unsigned int res = 2333;
        return res += res << 2 | 1;
    }
    inline int random(int x, int y) {
        return Rand() % (x + y) < x;
    }
     
    void build(node *&p, int l, int r, int *a) {
        if (l > r) {
            p = null;
            return;
        }
        p = new(a[l + r >> 1])node;
        if (l == r) {
            p -> update();
            return;
        }
        build(p -> ls, l, (l + r >> 1) - 1, a);
        build(p -> rs, (l + r >> 1) + 1, r, a);
        p -> update();
    }
     
    void merge(node *&p, node *x, node *y) {
        if (x == null || y == null)
            p = x == null ? y -> push() : x -> push();
        else if (random(x -> sz, y -> sz)) {
            p = x -> push();
            merge(p -> rs, x -> rs, y);
        } else {
            p = y -> push();
            merge(p -> ls, x, y -> ls);
        }
        p -> update();
    }
     
    void split(node *p, node *&x, node *&y, int k) {
        if (!k) {
            x = null, y = p -> push();
            return;
        }
        if (k == p -> sz) {
            x = p -> push(), y = null;
            return;
        }
        if (p -> ls -> sz >= k) {
            y = p -> push();
            split(p -> ls, x, y -> ls, k);
            y -> update();
        } else {
            x = p -> push();
            split(p -> rs, x -> rs, y, k - p -> ls -> sz - 1);
            x -> update();
        }
    }
}
using namespace treap;
 
int n;
int a[N];
 
int main() {
    int Q, i, oper, l, r;
    node *x, *y, *z;
    init();
    n = read(), Q = read();
    for (i = 1; i <= n; ++i) a[i] = get_c();
    build(root, 1, n, a);
    while (Q--) {
        oper = get_op(), l = read(), r = read();
        split(root, x, y, l - 1), split(y, y, z, r - l + 1);
        if (oper == 0) y -> replace(get_c());
        else if (oper == 1) printf("%d\n", (y -> maxr + 1) / 2 - (y -> minl - 1) / 2);
        else if (oper == 2) y -> reverse();
        else if (oper == 3) y -> inverse();
        merge(root, x, y -> push()), merge(root, root, z);
    }
    return 0;
}
 
inline int read() {
    register int x = 0;
    register char ch = getchar();
    while (ch < '0' || '9' < ch) ch = getchar();
    while ('0' <= ch && ch <= '9')
        x = x * 10 + ch - '0', ch = getchar();
    return x;
}
 
inline int get_c() {
    register char ch = getchar();
    while (ch != '(' && ch != ')') ch = getchar();
    return ch == '(' ? 1 : -1;
}
 
inline int get_op() {
    register char ch = getchar();
    while (ch != 'R' && ch != 'Q' && ch != 'S' && ch != 'I') ch = getchar();
    if (ch == 'R') return 0;
    if (ch == 'Q') return 1;
    if (ch == 'S') return 2;
    if (ch == 'I') return 3;
}