BZOJ 2329 HNOI 2011 括号修复 —— 标记处理的原则

裸的数据结构题不提示啦 ， 听说暴力也能过QAQ

这里主要谈谈踢标记的原则。
在很多数据结构 ， 例如线段树，平衡树…… ， 我们需要添上一些LazyTag来保证这些数据结构能在 lg(n) 的时间复杂度内处理问题。

然而如果有多个操作的时候 ， 下移操作会显得有些麻烦。 如果我们没有一个固定的原则来处理这些标记，那么我们每次都要考虑如何正确的下移这些 tags

我们先来看看标记本身的特性：

常见的标记有赋值，添加，翻转或者四则运算等等。我们可以把操作当作运算符一样分优先级，例如赋值的优先级就比添加要高而乘法的优先级也理应比加法高。而有一些强势的操作可以清除其他的操作（例如赋值），有些操作可能改变节点本身的权值（例如添加会影响节电本身的权值但是翻转不会），有些操作可能需要我们交换子树（例如翻转）。

一个处理标记行之有效的原则：

可以说因为每个操作有自己的特性，让下移他们变得复杂，其实我们只需要坚持一个 Rule 那么我们就不需要纠结操作之间分复杂关系和互相影响的麻烦。

在任何一个时刻 ， 节点所记录的信息在囊括自己和子孙节点的所有标记 的前提下是正确的。

换句话说，此时我们完全可以把这个节点单独抽出来作为一棵独立的平衡树来讨论。
这个原则很简单，但并不是所有人都是这样做的。在《训练指南》的很多范例代码中都是在节点标记下移的过程中更新节点信息的，也就是说如果不下移这个节点的标记，这个节点纪录的信息就是错误的。

这种做法会导致一些暗伤，而且可能让你的 maintain 函数变的异常麻烦。
以前博主就是这样实现的， 所以在线段树中我经常犯这样一个错误：（注意此时有标记）

int query(int o , int l , int r , int x)
{
    if(l == r) return seg[o].v;
    .
    .
    .

}

这样写是 bug 的，因为此时如果我不推 seg[o] 的标记，此时的 seg[o].v 是错误的。

再来看本题的 Splay
在 Splay 中我们经常用到的 maintain() 或者 pushUp() 函数从子树来更新节点的值。如果我们在 maintain() 中维护各个标记的种种，听起来就很麻烦。而且会增加代码的常数。但是如果坚持我刚刚提到的原则，我们就不需要考虑在 maintain() 函数中维护各个标记的值，原因很简单。当你需要调用这个函数的时候，所有的标记都已经清空了。

最后值得一提的是，当我们推标记的时候先踢下优先级较高的。

本题的代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <deque>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <cassert>

using namespace std;
const int maxn = 1e5+1e2;

int n , m;
char s[maxn];

struct node
{   
    node* ch[2];
    int v , s , ln , lx , rn , rx , t1 , t2 , t3;
    node() { s = v = ln = lx = rn = rx = t1 = t2 = t3 = 0; }
    int cmp(int d) { return d == ch[0]->s + 1 ? -1 : d <= ch[0]->s ? 0 : 1; }
    void maintain()
    {
        s = ch[0]->s + 1 + ch[1]->s;
        ln = min(ch[0]->ln , ch[0]->ln+ch[0]->rx+v+ch[1]->ln);
        lx = max(ch[0]->lx , ch[0]->ln+ch[0]->rx+v+ch[1]->lx);
        rn = min(ch[1]->rn , ch[1]->ln+ch[1]->rx+v+ch[0]->rn);
        rx = max(ch[1]->rx , ch[1]->ln+ch[1]->rx+v+ch[0]->rx);
    }

    void tag1(int x)
    {
        v = t1 = x , t2 = t3 = 0;
        ln = rn = min(0 , s*x);
        lx = rx = max(0 , s*x);
    }

    void tag2()
    {
        t2 ^= 1; 
        swap(ln, rn); swap(lx, rx); swap(ch[0], ch[1]);
    }

    void tag3()
    {
        t3 ^= 1; v = -v;
        ln *= -1; lx *= -1; rn *= -1; rx *= -1;
        swap(ln, lx); swap(rn, rx);
    }

    void pushDown()
    {
        if(t1) ch[0]->tag1(t1) , ch[1]->tag1(t1);
        if(t2) ch[0]->tag2() , ch[1]->tag2();
        if(t3) ch[0]->tag3() , ch[1]->tag3();
        t1 = t2 = t3 = 0;
    }
};

node* null = new node();
node pool[maxn]; int CNT;

node* newNode() { pool[CNT].ch[0] = pool[CNT].ch[1] = null; return &pool[CNT++]; }

inline void rotate(node *&o , int d)
{
    node* k = o->ch[d^1];
    o->ch[d^1] = k->ch[d];
    k->ch[d] = o;

    o->maintain();
    k->maintain();
    o = k;
}

void splay(node *&o , int k)
{
    o->pushDown();
    int d = o->cmp(k);
    if(d == 1) k -= o->ch[0]->s + 1;
    if(d != -1)
    {
        node *&o2 = o->ch[d];
        o2->pushDown();
        int d2 = o2->cmp(k);
        if(d2 == 1) k -= o2->ch[0]->s + 1;
        if(d2 != -1)
        {
            splay(o2->ch[d2], k);
            if(d == d2) rotate(o, d^1); else rotate(o2, d2^1);
        }
        rotate(o, d^1);
    }
}

node* root;
inline node* range(int l , int r)
{
    splay(root, l);
    splay(root->ch[1], r-l+2);
    return root->ch[1]->ch[0];
}

int id(char c) { return c=='('?1:c==')'?-1:0; }
node* build(int l , int r)
{
    if(l > r) return null;
    int mid = (l+r)/2;
    node* res = newNode();

    res->v = id(s[mid]);
    res->ch[0] = build(l, mid-1);
    res->ch[1] = build(mid+1, r);
    res->maintain();
    return res;
}

int main(int argc, char *argv[]) {

    cin>>n>>m;
    scanf("%s" , s+1);
    root = build(0, strlen(s+1)+1);

    char op[10] , ne[3]; int x , y , z;
    while(m--)
    {
        scanf("%s%d%d" , op , &x , &y);

        node *now = range(x, y);
        if(op[0] == 'R') 
        {
            scanf("%s" , ne);
            z = id(ne[0]);
            now->tag1(z);
        }
        if(op[0] == 'S') now->tag2();
        if(op[0] == 'I') now->tag3();
        if(op[0] == 'Q') printf("%d\n" , (-now->ln+1)/2 + (now->rx+1)/2);
        root->ch[1]->maintain(); root->maintain();
    }

    return 0;
}