[NOI2005]维护数列

[LuoguP2042]

肝了一晚上和一上午，先把代码发了，等有时间(假期？)把较为详细的解释补一下(逃

Code：

#include <bits/stdc++.h>
#define ll long long
#define L(x) e[x].son[0]
#define R(x) e[x].son[1]
#define lx(x) e[x].left
#define rx(x) e[x].right
#define mx(x) e[x].mx
#define sum(x) e[x].sum
using namespace std;
const int N = 1e6 + 7;
const int inf = 0x3f3f3f3f;
ll read() {
    ll re = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {if (ch == '-') f = -f; ch = getchar();}
    while ('0' <= ch && ch <= '9') {re = re * 10 + ch - '0'; ch = getchar();}
    return re * f;
}
int n, m, root, cnt;
struct node{
    int val, father;
    int son[2];
    int siz;
    int sum, mx;
    int left, right;
    bool tag, rev;
}e[N];
int top, a[N], id[N], rub[N];
void update(int x) {
    int l = L(x), r = R(x);
    sum(x) = sum(l) + sum(r) + e[x].val;
    e[x].siz = e[l].siz + e[r].siz + 1;
    mx(x) = max(mx(l), max(mx(r), rx(l) + e[x].val + lx(r)));
    lx(x) = max(lx(l), sum(l) + e[x].val + lx(r));
    rx(x) = max(rx(r), sum(r) + e[x].val + rx(l));
}
void pushdown(int x) {
    int l = L(x), r = R(x);
    if (e[x].tag) {
        e[x].tag = e[x].rev = false;
        if (l) {
            e[l].tag = true, e[l].val = e[x].val, sum(l) = e[x].val * e[l].siz;
            lx(l) = rx(l) = max(sum(l), 0);
            mx(l) = max(sum(l), e[l].val);
        }
        if (r) {
            e[r].tag = true, e[r].val = e[x].val, sum(r) = e[x].val * e[r].siz;
            lx(r) = rx(r) = max(sum(r), 0);
            mx(r) = max(sum(r), e[r].val);
        }
    }
    if (e[x].rev) {
        e[x].rev = false;
        e[l].rev ^= 1, e[r].rev ^= 1;
        swap(lx(l), rx(l)), swap(lx(r), rx(r));
        swap(L(l), R(l)), swap(L(r), R(r));
    }
}
void connect(int x, int fa, int Son) {
    e[x].father = fa;
    e[fa].son[Son] = x;
}
int identify(int x) {
    return L(e[x].father) == x ? 0 : 1;
}
void rotate(int x) {
    int fa = e[x].father, fason = identify(x);
    int gfa = e[fa].father, gfason = identify(fa);
    int B = e[x].son[fason ^ 1];
    connect(B, fa, fason), connect(fa, x, fason ^ 1);
    connect(x, gfa, gfason);
    update(fa), update(x);
}
void splay(int now, int to) {
    int tofa = e[to].father;
    while (e[now].father != tofa) {
        int fa = e[now].father, gfa = e[fa].father;
        if (gfa != tofa) {
            rotate(identify(now) == identify(fa) ? fa : now);
        }
        rotate(now);
    }
    if (to == root) root = now;
}
int kth(int rank) {
    int now = root;
    while (true) {
        pushdown(now);
        if (e[L(now)].siz >= rank) {
            now = L(now);
        } else {
            rank -= e[L(now)].siz + 1;
            if (!rank) return now;
            now = R(now);
        }
    }
}
int split(int k, int tot) {
    int x = kth(k), y = kth(k + tot + 1);
    splay(x, root), splay(y, R(x));
    return L(y);
}
void Reverse(int k, int tot) {
    int x = split(k, tot), y = e[x].father;
    if (!e[x].tag) {
        e[x].rev ^= 1;
        swap(L(x), R(x));
        swap(lx(x), rx(x));
        update(y), update(e[y].father);
    }
}
int rubbish() {
    if (!top) return ++cnt;
    int x = rub[top--];
    return x;
}
void build(int l, int r, int fa) {
    int mid = (l + r) / 2;
    int now = id[mid], pre = id[fa];
    if (l == r) {
        mx(now) = sum(now) = a[l];
        e[now].tag = e[now].rev = false;
        lx(now) = rx(now) = max(a[l], 0);
        e[now].siz = 1;
    }
    if (l < mid) build(l, mid - 1, mid);
    if (r > mid) build(mid + 1, r, mid);
    e[now].val = a[mid], e[now].father = pre, e[now].tag = 0;
    update(now);
    e[pre].son[mid >= fa] = now;
}
void Insert(int k, int tot) {
    for (int i = 1; i <= tot; i++) a[i] = read();
    for (int i = 1; i <= tot; i++) {
        id[i] = rubbish();
    }
    build(1, tot, 0);
    int z = id[(1 + tot) / 2];
    int x = kth(k + 1), y = kth(k + 2);
    splay(x, root), splay(y, R(x));
    connect(z, y, 0);
    update(y), update(x);
}
void remove(int x) {
    if (L(x)) remove(L(x));
    if (R(x)) remove(R(x));
    rub[++top] = x;
    e[x].father = L(x) = R(x) = e[x].tag = e[x].rev = 0;
}
void Erase(int k, int tot) {
    int x = split(k, tot), y = e[x].father;
    remove(x);
    L(y) = 0;
    update(y), update(e[y].father);
}
void change(int k, int tot, int v) {
    int x = split(k, tot), y = e[x].father;
    e[x].val = v, e[x].tag = true;
    sum(x) = e[x].siz * v;
    lx(x) = rx(x) = max(sum(x), 0);
    mx(x) = max(sum(x), e[x].val);
    update(y), update(e[y].father);
}
int query(int k, int tot) {
    int x = split(k, tot);
    return sum(x);
}
int main () {
    n = read(), m = read();
    mx(0) = a[1] = a[n + 2] = -inf;
    for (int i = 1; i <= n; i++) a[i + 1] = read();
    for (int i = 1; i <= n + 2; i++) id[i] = i;
    build(1, n + 2, 0);
    root = (n + 3) / 2;
    cnt = n + 2;
    int k, tot, v;
    string s;
    while (m--) {
        cin >> s;
        if (s != "MAX-SUM") {
            k = read(), tot = read();
        } else {
            printf("%d
", mx(root));
        }
        if (s == "INSERT") Insert(k, tot);
        if (s == "DELETE") Erase(k, tot);
        if (s == "MAKE-SAME") {
            v = read();
            change(k, tot, v);
        }
        if (s == "REVERSE") Reverse(k, tot);
        if (s == "GET-SUM") printf("%d
", query(k, tot));
    }
    return 0;
}