bzoj1251: 序列终结者 splay

Time Limit: 20 Sec Memory Limit: 162 MB

Description
网上有许多题，就是给定一个序列，要你支持几种操作：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。

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

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

Sample Input
4 4

1 1 3 2

1 2 4 -1

2 1 3

3 2 4

Sample Output
2

【数据范围】

N<=50000，M<=100000。

splay模板题，区间更新，翻转，求最大值

#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXN = 50003;
const int INF = 0x3f3f3f3f;
int n, m, sz, rt;
int val[MAXN], id[MAXN];
int tr[MAXN][2], size[MAXN], fa[MAXN], rev[MAXN], s[MAXN], lazy[MAXN];

void push_up(int x) {
    int l = tr[x][0], r = tr[x][1];
    s[x] = max(val[x], max(s[l], s[r]));
    size[x] = size[l] + size[r] + 1;
}

void push_down(int x) {
    int l = tr[x][0], r = tr[x][1];
    if(lazy[x]) {
        if(l) {
            lazy[l] += lazy[x];
            s[l] += lazy[x];
            val[l] += lazy[x];
        }
        if(r) {
            lazy[r] += lazy[x];
            s[r] += lazy[x];
            val[r] += lazy[x];
        }
        lazy[x] = 0;
    }
    if(rev[x]) {
        rev[x] = 0;
        rev[l] ^= 1; rev[r] ^= 1;
        swap(tr[x][0], tr[x][1]);
    }
}

void rotate(int x, int &k) {
    int y = fa[x];
    int z = fa[y];
    int l, r;
    if(tr[y][0] == x) l = 0;
    else l = 1;
    r = l ^ 1;
    if(y == k) k = x;
    else {
        if(tr[z][0] == y) tr[z][0] = x;
        else tr[z][1] = x;
    }
    fa[x] = z; fa[y] = x; fa[tr[x][r]] = y;
    tr[y][l] = tr[x][r]; tr[x][r] = y;
    push_up(x); push_up(y);
}

void splay(int x, int &k) {
    int y, z;
    while(x != k) {
        y = fa[x];
        z = fa[y];
        if(y != k) {
            if((tr[y][0] == x) ^ (tr[z][0] == y)) rotate(x, k);
            else rotate(y, k);
        }
        rotate(x, k);
    }
}

int find(int x, int rank) {
    push_down(x);
    int l = tr[x][0], r = tr[x][1];
    if(size[l] + 1 == rank) return x;
    else if(size[l] >= rank) return find(l, rank);
    else return find(r, rank - size[l] - 1);
}

void update(int l, int r, int v) {
    int x = find(rt, l), y = find(rt, r + 2);
    splay(x, rt); splay(y, tr[x][1]);
    int z = tr[y][0];
    lazy[z] += v;
    val[z] += v;
    s[z] += v;
}

void reverse(int l, int r) {
    int x = find(rt, l), y = find(rt, r + 2);
    splay(x, rt); splay(y, tr[x][1]);
    int z = tr[y][0];
    rev[z] ^= 1;
}

void query(int l, int r) {
    int x = find(rt, l), y = find(rt, r + 2);
    splay(x, rt); splay(y, tr[x][1]);
    int z = tr[y][0];
    printf("%d\n", s[z]);
}

void build(int l, int r, int f) {
    if(l > r) return;
    int now = id[l], last = id[f];
    if(l == r) {
        fa[now] = last; size[now] = 1;
        if(l < f) tr[last][0] = now;
        else tr[last][1] = now;
        return;
    }
    int mid = (l + r) >> 1; now = id[mid];
    build(l, mid - 1, mid); build(mid + 1, r, mid);
    fa[now] = last;
    push_up(now);
    if(mid < f) tr[last][0] = now;
    else tr[last][1] = now;
}

int main() {
    s[0] = -INF;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n + 2; i++) id[i] = ++sz;
    build(1, n + 2, 0); rt = (n + 3) >> 1;
    int ki, l, r, v;
    while(m--) {
        scanf("%d", &ki);
        if(ki == 1) {
            scanf("%d%d%d", &l, &r, &v);
            update(l ,r, v);
        }
        else if(ki == 2) {
            scanf("%d%d", &l, &r);
            reverse(l, r);
        }
        else {
            scanf("%d%d", &l, &r);
            query(l, r);
        }
    }
    return 0;
}