[LGOJ4146]序列终结者——[splay]

【题目描述】

网上有许多题，就是给定一个序列，要你支持几种操作：A、B、C、D。一看另一道题，又是一个序列要支持几种操作：D、C、B、A。尤其是我们这里的某人，出模拟试题，居然还出了一道这样的，真是没技术含量……

这样我也出一道题，我出这一道的目的是为了让大家以后做这种题目有一个“库”可以依靠，没有什么其他的意思。

这道题目就叫序列终结者吧。

给定一个长度为N的序列，每个序列的元素是一个整数（废话）。要支持以下三种操作：

• 1.将[L,R]这个区间内的所有数加上V。
• 2.将[L,R]这个区间翻转，比如1 2 3 4变成4 3 2 1。
• 3.求[L,R]这个区间中的最大值。

最开始所有元素都是0。

【输入格式】

第一行两个整数N，M。M为操作个数。
以下M行，每行最多四个整数，依次为K，L，R，V。K表示是第几种操作，如果不是第1种操作则K后面只有两个数.

【输出格式】

对于每个第3种操作，给出正确的回答。

$SampleInput$

4 4
1 1 3 2
1 2 4 -1
2 1 3
3 2 4

$SampleOutput$

2

【题意分析】

主要就是splay打标记，add和rev标记一起下传。
提取区间的话，找一下l和r+2，然后把l旋到根，r+2旋到根的右子树。
那么很明显根的右子树的左子树就是要提取的区间了（比l大，比r+2小，那么就是先右子树再左子树）

Code：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include <algorithm>
#define MAXN 100000
#define INF 1 << 28
using namespace std;

int data[MAXN], n, m, sz, root;

struct spaly {
    
    int size[MAXN], mx[MAXN], val[MAXN], son[MAXN][3], rev[MAXN], lazy[MAXN], father[MAXN];
    
    inline void maintain (int x) {
        size[x] = size[son[x][0]] + size[son[x][1]] + 1;
        mx[x] = max (val[x], max (mx[son[x][0]], mx[son[x][1]]));
    }
    
    inline void pushadd (int x, int y) {
        val[x] += y, lazy[x] += y, mx[x] += y;
    }
    
    inline void pushrev (int x) {
        rev[x] ^= 1;
        swap (son[x][0], son[x][1]);
    }
    
    inline void pushdown (int x) {
        if (lazy[x]) {
            if (son[x][0]) pushadd (son[x][0], lazy[x]);
            if (son[x][1]) pushadd (son[x][1], lazy[x]);
            lazy[x] = 0;
        }
        if (rev[x]) {
            if (son[x][0]) pushrev (son[x][0]);
            if (son[x][1]) pushrev (son[x][1]);
            rev[x] = 0;
        }
    }
    
    inline void rotate (int x) {
        int y = father[x], z = father[y];
        int k = son[y][1] == x, kk = son[z][1] == y;
        son[z][kk] = x;
        father[x] = z;
        son[y][k] = son[x][k ^ 1];
        father[son[x][k ^ 1]] = y;
        son[x][k ^ 1] = y;
        father[y] = x;
        maintain (y), maintain (x);
    }
    
    inline void splay (int x, int goal) {
        while (father[x] != goal) {
            int y = father[x], z = father[y];
            if (z != goal)
                (son[z][1] == y) ^ (son[y][1] == x)
                    ? rotate (x) : rotate (y);
            rotate (x);
        }
        if (! goal) root = x;
    }
    
    int Kth (int x, int rank) {
        pushdown (x);
        if (son[x][0] && rank <= size[son[x][0]]) return Kth (son[x][0], rank);
        return (rank <= size[son[x][0]] + 1)
            ? x : Kth (son[x][1], rank - size[son[x][0]] - 1);
    }
    
    inline int split (int l, int r) {
        l = Kth (root, l), r = Kth (root, r + 2);
        splay (l, 0), splay (r, l);
        return son[son[root][1]][0];
    }
    
    inline void add (int l, int r, int k) {
        int now = split (l, r);
        pushadd (now, k);
        maintain (son[root][1]);
        maintain (root);
    }
    
    inline void reverse (int l, int r) {
        int now = split (l, r);
        pushrev (now);
        maintain (son[root][1]);
        maintain (root);
    }
    
    inline int query (int l, int r) {
        int now = split (l, r);
        return mx[now];
    }
    
    int build (int l, int r, int fa) {
        if (l > r) return 0;
        if (l == r) {
            father[l] = fa;
            mx[l] = val[l] = data[l];
            size[l] = 1; return l;
        }
        int mid = l + r >> 1;
        son[mid][0] = build (l, mid - 1, mid);
        son[mid][1] = build (mid + 1, r, mid);
        val[mid] = data[mid];
        father[mid] = fa; maintain (mid);
        return mid;
    }
    
}tree;

int main () {
    scanf ("%d%d", &n, &m);
    data[1] = data[n + 2] = tree.mx[0] = -INF;
    root = tree.build (1, n + 2, 0);
    for (register int i = 1; i <= m; i++) {
        int opt, L, R, k; scanf ("%d", &opt);
        if (opt == 1) {
            scanf ("%d%d%d", &L, &R, &k);
            tree.add (L, R, k);
        }
        if (opt == 2) {
            scanf ("%d%d", &L, &R);
            tree.reverse (L, R);
        }
        if (opt == 3) {
            scanf ("%d%d", &L, &R);
            printf ("%d\n", tree.query (L, R));
        }
    }
    return 0;
}