BZOJ 1500|NOI 2005|维修数列|Splay

#include <cstdio>
#include <stdexcept>
#include <algorithm>
using namespace std;
#define inf 1000000000
#define N 1000005

int read() {
int s = 0, f = 1; char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') f = -1;
for (; '0' <= ch && ch <= '9'; ch = getchar()) s = s * 10 + ch - '0';
return s * f;
}

template<typename T>
class Splay {
public:
Splay(T a[], int n) {
init(a, n);
}

void cover(int startIndex, int length, T val) {
Node *x = subsequence(startIndex, length), *y = x->fa;
cover_impl(x, val);
update(y); update(y->fa);
}

void reverse(int startIndex, int length) {
Node *x = subsequence(startIndex, length), *y = x->fa;
if (!x->tag) {
reverse_impl(x);
update(y); update(y->fa);
}
}

void erase(int startIndex, int length) {
Node *x = subsequence(startIndex, length), *y = x->fa;
delete_recursively(x); y->left() = Node::null;
update(y); update(y->fa);
}

T getSum(int startIndex, int length) {
return subsequence(startIndex, length)->sum;
}

T getMaxSubsequence() {
return root->mx;
}

void insert(T a[], int startIndex, int length) {
Node *z = build(a, 0, length - 1);
Node *x = find(root, startIndex + 1);
Node *y = find(root, startIndex + 2);
splay(x, root);
splay(y, x->right());
z->fa = y; y->left() = z;
update(y); update(x);
}
private:

struct Node {
Node *c[2], *fa;
int size;
T sum, val, mx, lx, rx;
bool tag, rev;

Node(T v) {
c[0] = c[1] = fa = Node::null;
size = 1;
sum = val = mx = v;
if (v >= 0) lx = rx = v;
else lx = rx = 0;
tag = rev = 0;
}

Node *&left() { return c[0]; }
Node *&right() { return c[1]; }

void *operator new(size_t size) {
static Node *preserve = NULL;
static int cnt = 0;
Node *r;
if (free_pointer == null) {
// allocate memory lazily
if (preserve == NULL || cnt == 0) {
preserve = (Node *) malloc(size * N);
cnt = N;
}
r = &preserve[--cnt];
} else {
// reuse recycled memory
r = free_pointer;
free_pointer = free_pointer->fa;
}
return r;
}

void operator delete(void *p) {
if (p == NULL || p == null) return;
Node *q = static_cast<Node *>(p);
q->fa = free_pointer;
free_pointer = q;
}

static Node *null;
private:
Node() {
c[0] = c[1] = fa = this;
sum = size = val = lx = rx = tag = rev = 0;
mx = -inf;
}
static Node *free_pointer;
} *root;

void update(Node *x) {
if (x == Node::null) return;
Node *l = x->left(), *r = x->right();
x->sum = l->sum + r->sum + x->val;
x->size = l->size + r->size + 1;
x->mx = max(max(l->mx, r->mx), l->rx + x->val + r->lx);
x->lx = max(l->lx, l->sum + x->val + r->lx);
x->rx = max(r->rx, r->sum + x->val + l->rx);
}

void cover_impl(Node *c, T val) {
if (c == Node::null || c == NULL)
return;
c->tag = 1;
c->val = val;
c->sum = val * c->size;
if (val >= 0) {
c->lx = c->rx = c->mx = c->sum;
} else {
c->lx = c->rx = 0;
c->mx = val;
}
}

void reverse_impl(Node *x) {
if (x == Node::null || x == NULL)
return;
x->rev ^= 1;
swap(x->left(), x->right());
swap(x->lx, x->rx);
}

void pushdown(Node *x) {
Node *l = x->left(), *r = x->right();
if (x->tag) {
cover_impl(l, x->val);
cover_impl(r, x->val);
x->rev = x->tag = 0;
}
if (x->rev) {
x->rev ^= 1;
reverse_impl(x->left());
reverse_impl(x->right());
}
}

void rotate(Node *x, Node *&dest) {
Node *y = x->fa, *z = y->fa;
int l = y->right() == x, r = l ^ 1;
if (y == dest) dest = x;
else z->c[z->right() == y] = x;
x->c[r]->fa = y; y->fa = x; x->fa = z;
y->c[l] = x->c[r]; x->c[r] = y;
update(y); update(x);
}

void splay(Node *x, Node *&dest) {
while (x != dest) {
Node *y = x->fa, *z = y->fa;
if (y != dest) {
if ((y->left() == x) ^ (z->left() == y)) rotate(x, dest);
else rotate(y, dest);
}
rotate(x, dest);
}
}

Node *find(Node *x, int rank) {
pushdown(x);
if (x->left()->size + 1 == rank)
return x;
if (x->left()->size >= rank)
return find(x->left(), rank);
return find(x->right(), rank - x->left()->size - 1);
}

void delete_recursively(Node *x) {
if (x == Node::null) return;
delete_recursively(x->left());
delete_recursively(x->right());
delete x;
}

Node *&subsequence(int startIndex, int length) {
// for initialization, adding -oo forward and backward.
Node *x = find(root, startIndex), *y = find(root, startIndex + length + 1);
splay(x, root); splay(y, x->right());
return y->left();
}

void init(T a[], int n) {
for (int i = n; i; --i)
a[i] = a[i - 1];
a[0] = a[n + 1] = -inf;
root = build(a, 0, n + 1);
}

Node *build(T a[], int l, int r, Node *fa = Node::null) {
if (l > r) return Node::null;
int mid = (l + r) / 2;
Node *now = new Node(a[mid]);
now->fa = fa;
if (l != r) {
now->left() = build(a, l, mid - 1, now);
now->right() = build(a, mid + 1, r, now);
}
update(now);
return now;
}
};
template<typename T> typename Splay<T>::Node *Splay<T>::Node::null = new Node();
template<typename T> typename Splay<T>::Node *Splay<T>::Node::free_pointer = Node::null;

int main() {
static int a
;
int i, n, m, k, tot, val;
char ch[10];

n = read(); m = read();
for (i = 0; i < n; ++i) a[i] = read();
Splay<int> *splay = new Splay<int>(a, n);

while(m--) {
scanf("%s", ch);
if (ch[0] != 'M' || ch[2] != 'X') k = read(), tot = read();
if (ch[0] == 'I') {
for (i = 0; i < tot; ++i) a[i] = read();
splay->insert(a, k, tot);
}
if (ch[0] == 'D') splay->erase(k, tot);
if (ch[0] == 'M') {
if (ch[2] == 'X') printf("%d\n", splay->getMaxSubsequence());
else val = read(), splay->cover(k, tot, val);
}
if (ch[0] == 'R') splay->reverse(k, tot);
if (ch[0] == 'G') printf("%d\n", splay->getSum(k, tot));
}
return 0;
}