【HYSBZ】1500 维修数列

#include<cstdio>
#include<cstring>
#include<algorithm>
#define oo 0x7FFFFFFF
#define MAXN 1000010
using namespace std;
struct SplayTree {
    int root, size;
    int a[MAXN], st[MAXN], top;
    int next[MAXN][2], pre[MAXN], key[MAXN], num[MAXN];
    bool flip[MAXN];
    int same[MAXN], sum[MAXN], MaxL[MAXN], MaxR[MAXN], MaxM[MAXN];
    inline void PushUp(int x) {
        int L, R;
        L = next[x][0];
        R = next[x][1];
        num[x] = num[L] + num[R] + 1;
        sum[x] = sum[L] + sum[R] + key[x];
        MaxL[x] = max(MaxL[L], sum[L] + key[x] + max(MaxL[R], 0));
        MaxR[x] = max(MaxR[R], sum[R] + key[x] + max(MaxR[L], 0));
        MaxM[x] = max(MaxM[L], MaxM[R]);
        MaxM[x] = max(MaxM[x], max(MaxR[L], 0) + key[x] + max(MaxL[R], 0));
    }
    inline void PushDown(int x) {
        int L, R;
        L = next[x][0];
        R = next[x][1];
        if (flip[x]) {
            flip[x] = false;
            swap(next[x][0], next[x][1]);
            if (L) {
                flip[L] ^= true;
                swap(MaxL[L], MaxR[L]);
            }
            if (R) {
                flip[R] ^= true;
                swap(MaxL[R], MaxR[R]);
            }
        }
        if (same[x] != -oo) {
            if (L) {
                same[L] = key[L] = same[x];
                sum[L] = num[L] * same[x];
                MaxL[L] = MaxR[L] = MaxM[L] = max(same[x], sum[L]);
            }
            if (R) {
                same[R] = key[R] = same[x];
                sum[R] = num[R] * same[x];
                MaxL[R] = MaxR[R] = MaxM[R] = max(same[x], sum[R]);
            }
            same[x] = -oo;
        }
    }
    void NewNode(int &x, int father, int val) {
        if (top != -1)
            x = st[top--];
        else
            x = ++size;
        flip[x] = false;
        next[x][0] = next[x][1] = 0;
        pre[x] = father;
        key[x] = sum[x] = MaxL[x] = MaxR[x] = MaxM[x] = val;
        num[x] = 1;
        same[x] = -oo;
    }
    void Build(int &x, int L, int R, int father) {
        if (L <= R) {
            int mid = (L + R) >> 1;
            NewNode(x, father, a[mid]);
            Build(next[x][0], L, mid - 1, x);
            Build(next[x][1], mid + 1, R, x);
            PushUp(x);
        }
    }
    void Init(int n) {
        top = -1;
        root = size = 0;
        next[0][0] = next[0][1] = pre[0] = key[0] = num[0] = sum[0] = 0;
        flip[0] = false;
        same[0] = MaxL[0] = MaxR[0] = MaxM[0] = -oo;
        NewNode(root, 0, -oo);
        NewNode(next[root][1], root, -oo);
        Build(next[next[root][1]][0], 1, n, next[root][1]);
        PushUp(next[root][1]);
        PushUp(root);
    }
    void Rotate(int x, int kind) {
        int y, z;
        y = pre[x];
        z = pre[y];
        PushDown(y);
        next[y][!kind] = next[x][kind];
        pre[next[x][kind]] = y;
        next[z][next[z][1] == y] = x;
        pre[x] = z;
        next[x][kind] = y;
        pre[y] = x;
        PushUp(y);
    }
    void Splay(int x, int goal) {
        if (x != goal) {
            PushDown(x);
            while (pre[x] != goal) {
                if (next[pre[x]][0] == x)
                    Rotate(x, 1);
                else
                    Rotate(x, 0);
            }
            PushUp(x);
            if (!goal)
                root = x;
        }
    }
    int Select(int k) {
        int x;
        PushDown(root);
        for (x = root; num[next[x][0]] + 1 != k;) {
            if (num[next[x][0]] + 1 > k)
                x = next[x][0];
            else {
                k -= num[next[x][0]] + 1;
                x = next[x][1];
            }
            PushDown(x);
        }
        return x;
    }
    int GetSum(int x, int y) {
        x = Select(x - 1);
        y = Select(y + 1);
        Splay(x, 0);
        Splay(y, x);
        return sum[next[y][0]];
    }
    void Recycle(int x) {
        if (x) {
            st[++top] = x;
            Recycle(next[x][0]);
            Recycle(next[x][1]);
        }
    }
    void Delete(int x, int y) {
        x = Select(x - 1);
        y = Select(y + 1);
        Splay(x, 0);
        Splay(y, x);
        Recycle(next[y][0]);
        next[y][0] = 0;
        PushUp(y);
        PushUp(x);
    }
    void Flip(int x, int y) {
        x = Select(x - 1);
        y = Select(y + 1);
        Splay(x, 0);
        Splay(y, x);
        y = next[y][0];
        flip[y] ^= true;
        swap(MaxL[y], MaxR[y]);
    }
    void MakeSame(int x, int y, int val) {
        int t;
        x = Select(x - 1);
        y = Select(y + 1);
        Splay(x, 0);
        Splay(y, x);
        t = next[y][0];
        same[t] = key[t] = val;
        sum[t] = val * num[t];
        MaxL[t] = MaxR[t] = MaxM[t] = max(val, sum[t]);
        PushUp(y);
        PushUp(x);
    }
    int GetMin(int x) {
        PushDown(x);
        while (next[x][0]) {
            x = next[x][0];
            PushDown(x);
        }
        return x;
    }
    void Insert(int x, int cnt) {
        int y;
        x = Select(x);
        Splay(x, 0);
        y = GetMin(next[x][1]);
        Splay(y, x);
        Build(next[y][0], 1, cnt, y);
        PushUp(y);
        PushUp(x);
    }
    int MaxSum(int x, int y) {
        x = Select(x - 1);
        y = Select(y + 1);
        Splay(x, 0);
        Splay(y, x);
        return MaxM[next[y][0]];
    }
} spt;
int main() {
    int n, q;
    int pos, cnt, i, val;
    char cmd[18];
    while (~scanf("%d%d", &n, &q)) {
        for (i = 1; i <= n; i++)
            scanf("%d", &spt.a[i]);
        spt.Init(n);
        while (q--) {
            scanf(" %s", cmd);
            if (strcmp(cmd, "GET-SUM") == 0) {
                scanf("%d%d", &pos, &cnt);
                printf("%d\n", spt.GetSum(pos + 1, pos + cnt));
            } else if (strcmp(cmd, "MAX-SUM") == 0)
                printf("%d\n", spt.MaxSum(2, spt.num[spt.root] - 1));
            else if (strcmp(cmd, "INSERT") == 0) {
                scanf("%d%d", &pos, &cnt);
                for (i = 1; i <= cnt; i++)
                    scanf("%d", &spt.a[i]);
                spt.Insert(pos + 1, cnt);
            } else if (strcmp(cmd, "DELETE") == 0) {
                scanf("%d%d", &pos, &cnt);
                spt.Delete(pos + 1, pos + cnt);
            } else if (strcmp(cmd, "MAKE-SAME") == 0) {
                scanf("%d%d%d", &pos, &cnt, &val);
                spt.MakeSame(pos + 1, pos + cnt, val);
            } else if (strcmp(cmd, "REVERSE") == 0) {
                scanf("%d%d", &pos, &cnt);
                spt.Flip(pos + 1, pos + cnt);
            }
        }
    }
    return 0;
}