BZOJ 1500 维修数列

维修数列

【问题描述】

【输入格式】

输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。
第2行包含N个数字，描述初始时的数列。
以下M行，每行一条命令，格式参见问题描述中的表格。
任何时刻数列中最多含有500 000个数，数列中任何一个数字均在[-1 000, 1 000]内。
插入的数字总数不超过4 000 000个，输入文件大小不超过20MBytes。

【输出格式】

对于输入数据中的GET-SUM和MAX-SUM操作，向输出文件依次打印结果，每个答案（数字）占一行。

【样例输入】

9 8
2 -6 3 5 1 -5 -3 6 3
GET-SUM 5 4
MAX-SUM
INSERT 8 3 -5 7 2
DELETE 12 1
MAKE-SAME 3 3 2
REVERSE 3 6
GET-SUM 5 4
MAX-SUM

【样例输出】

-1
10
1
10

【数据范围】

---

题解：

每一个操作都差不多是将通过将左右区间（开区间）端点转到根和右孩子

就能将整个区间转移到根的右孩子的左孩子的子树，就能直接取出信息了

#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 1e6;
const int inf = 2e9;
inline void Scan(int &x)
{
    char c;
    bool o = false;
    while(!isdigit(c = getchar())) o = (c != '-') ? o : true;
    x = c - '0';
    while(isdigit(c = getchar())) x = x * 10 + c - '0';
    if(o) x = -x;
}
int n, m;
int num;
int root;
int deln;
int del[maxn];
int id[maxn], pri[maxn];
int lc[maxn], rc[maxn], fat[maxn];
int si[maxn], sum[maxn], val[maxn], lmax[maxn], rmax[maxn], kmax[maxn];
int sam[maxn];
bool rev[maxn];
inline void Update(int x)
{
    int l = lc[x], r = rc[x];
    si[x] = si[l] + si[r] + 1;
    sum[x] = sum[l] + sum[r] + val[x];
    lmax[x] = max(lmax[l], sum[l] + val[x] + max(lmax[r], 0));
    rmax[x] = max(rmax[r], sum[r] + val[x] + max(rmax[l], 0));
    kmax[x] = max(kmax[l], kmax[r]);
    kmax[x] = max(kmax[x], rmax[l] + lmax[r] + val[x]);
    kmax[x] = max(kmax[x], max(max(rmax[l], lmax[r]), 0) + val[x]);
}
inline void Change(int x, int c)
{
    sam[x] = val[x] = c;
    sum[x] = si[x] * c;
    kmax[x] = lmax[x] = rmax[x] = c > 0 ? sum[x] : c;
}
inline void Rever(int x)
{
    rev[x] ^= 1;
    swap(lmax[x], rmax[x]);
    swap(lc[x], rc[x]);
}
inline void Down(int x)
{
    int l = lc[x], r = rc[x];
    if(rev[x])
    {
        Rever(l), Rever(r);
        rev[x] = 0;
    }
    if(sam[x] != inf)
    {
        Change(l, sam[x]), Change(r, sam[x]);
        sam[x] = inf;
    }
}
inline void Printtree(int k)
{
    if(!k) return;
    Down(k);
    printf("k=%d v=%d lc=%d rc=%d si=%d sum=%d
", k, val[k], lc[k], rc[k], si[k], sum[k]);
    Printtree(lc[k]);
    Printtree(rc[k]);
}
void Print(int k)
{
    if(!k) return;
    Down(k);
    Print(lc[k]);
    printf("%d ", val[k]);
    Print(rc[k]);
}
inline void Turn(int x)
{
    int y = fat[x], z = fat[y];
    int w = (lc[y] != x) ? lc[x] : rc[x];
    Down(y), Down(x);
    fat[y] = x;
    fat[x] = z;
    if(w) fat[w] = y;
    if(z)
        if(lc[z] == y) lc[z] = x;
        else rc[z] = x;
    if(lc[y] == x) rc[x] = y, lc[y] = w;
    else lc[x] = y, rc[y] = w;
    Update(y);
}
inline void Splay(int x, int anc)
{
    Down(x);
    while(fat[x] != anc)
    {
        if(fat[fat[x]] != anc)
            if((lc[fat[fat[x]]] == fat[x]) == (lc[fat[x]] == x)) Turn(fat[x]);
            else Turn(x);
        Turn(x);
    }
    Update(x);
    if(!anc) root = x;
}
int Build(int l, int r, int f)
{
    int mid = l + r >> 1;
    int k = id[mid];
    fat[k] = f;
    sam[k] = inf;
    val[k] = pri[mid];
    if(l == r) si[k] = 1;
    if(l < mid) lc[k] = Build(l, mid - 1, k);
    if(r > mid) rc[k] = Build(mid + 1, r, k);
    Update(k);
    return k;
}
inline int Find(int x)
{
    int k = root;
    while(true)
    {
        Down(k);
        int sum = si[lc[k]] + 1;
        if(sum == x) return k;
        if(sum > x) k = lc[k];
        else k = rc[k], x -= sum;
    }
}
inline void Clear(int x)
{
    lc[x] = rc[x] = fat[x] = 0;
    rev[x] = 0, sam[x] = inf;
}
inline void Modify(int l, int r, int c)
{
    int x = Find(l), y = Find(r);
    Splay(x, 0), Splay(y, x);
    int z = lc[y];
    Change(z, c);
    Update(y), Update(x);
}
inline void Insert(int l, int r, int n)
{
    int x = Find(l), y = Find(r);
    Splay(x, 0), Splay(y, x);
    int cnt = n;
    while(deln && cnt) id[cnt--] = del[deln--];
    while(cnt) id[cnt--] = ++num;
    int np = Build(1, n, 0);
    Down(y);
    lc[y] = np;
    fat[np] = y;
    Update(y), Update(x);
}
void Del(int x)
{
    if(!x) return;
    Del(lc[x]);
    del[++deln] = x;
    Del(rc[x]);
    Clear(x);
}
inline void Del(int l, int r)
{
    int x = Find(l), y = Find(r);
    Splay(x, 0), Splay(y, x);
    int z = lc[y];
    lc[y] = 0;
    Del(z);
    Update(y), Update(x);
}
inline void Reverse(int l, int r)
{
    int x = Find(l), y = Find(r);
    Splay(x, 0), Splay(y, x);
    int z = lc[y];
    Rever(z);
    Update(y), Update(x);
}
inline void Sum(int l, int r)
{
    int x = Find(l), y = Find(r);
    Splay(x, 0), Splay(y, x);
    int z = lc[y];
    printf("%d
", sum[z]);
}
inline void Max(int l, int r)
{
    int x = Find(l), y = Find(r);
    Splay(x, 0), Splay(y, x);
    int z = lc[y];
    printf("%d
", kmax[z]);
}
char s[233];
int main()
{
    Scan(n), Scan(m);
    num = n + 2;
    for(int i = 1; i <= n; ++i) Scan(pri[i + 1]);
    for(int i = 1; i <= num; ++i) id[i] = i;
    root = Build(1, num, 0);
    int pos, tot, c, l, r;
    while(m--)
    {
        scanf("%s", s);
        switch(s[0])
        {
            case 'I':
            {
                Scan(pos), Scan(tot);
                for(int i = 1; i <= tot; ++i) Scan(pri[i]);
                Insert(pos + 1, pos + 2, tot);
                break;
            }
            case 'D':
            {
                Scan(pos), Scan(tot);
                Del(pos, pos + tot + 1);
                break;
            }
            case 'R':
            {
                Scan(pos), Scan(tot);
                Reverse(pos, pos + tot + 1);
                break;
            }
            case 'G':
            {
                Scan(pos), Scan(tot);
                Sum(pos, pos + tot + 1);
                break;
            }
            case 'M':
            {
                if(s[4] == '-')
                {
                    Scan(pos), Scan(tot), Scan(c);
                    Modify(pos, pos + tot + 1, c);
                }
                else Max(1, si[root]);
                break;
            }
        }
    }
}