bzoj 1500 维修数列

一道操作很多的splay的题目。

还是和原来一样， 减少代码量， 在最左边和最右边都添加一个新的虚节点。

每一个节点都维护 从左端点开始的最大连续子序列， 右端点开始的最大连续子序列， 可以不取， 即为0， 还要维护这段区间的最大值。

每次Update的时候更新数据。

每次翻转的时候， 要把这个点的 左端点开始的最大连续子序列， 右端点开始的最大连续子序列 先进行交换，因为这个会对答案产生影响， 所以对于翻转区间来说， 要更新第一个翻转区间， 再打lazy， 不能直接不更新， 打lazy。

还有就是 bzoj 开数组很花费时间， 所以要写一个函数来回收已经被删除掉的点。

代码：

#include<bits/stdc++.h>
using namespace std;
#define Fopen freopen("_in.txt","r",stdin); freopen("_out.txt","w",stdout);
#define LL long long
#define ULL unsigned LL
#define fi first
#define se second
#define pb push_back
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
typedef pair<int,int> pll;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const LL mod =  (int)1e9+7;
const int N = 5e5 + 100;
int sta[N];
int c[N];
int top = 0, root;
struct Node{
    int son[2], pre;
    int sz, val;
    int lf, rt, maxx, sum, ma;
    int lz1, lz2;
    void init(int m){
        sum = maxx = val = m;
        lf = rt = ma = max(0, m);
        son[0] = son[1] = pre = 0;
        sz = 1;
        lz1 = lz2 = 0;
    }
}tr[N];
void GG(int x, int v){
    if(!x) return ;
    tr[x].lz2 = 1;
    tr[x].val = tr[x].maxx = v;
    tr[x].sum = tr[x].sz * v;
    tr[x].lf = tr[x].rt = tr[x].ma = max(0, tr[x].sum);
}
void Push_Up(int x){
    if(!x) return ;
    int &l = tr[x].son[0], &r = tr[x].son[1];
    tr[x].sz = 1 + tr[l].sz + tr[r].sz;
    tr[x].sum = tr[l].sum + tr[r].sum + tr[x].val;
    tr[x].maxx = max3(tr[x].val, tr[l].maxx, tr[r].maxx);
    tr[x].lf = max(tr[l].lf, tr[l].sum + tr[r].lf + tr[x].val);
    tr[x].rt = max(tr[r].rt, tr[r].sum + tr[l].rt + tr[x].val);
    tr[x].ma = max3(tr[l].ma, tr[r].ma, tr[l].rt + tr[r].lf + tr[x].val);
}
void Push_Down(int x){
    if(!x) return ;
    int &l = tr[x].son[0], &r = tr[x].son[1];
    if(tr[x].lz1){
        tr[x].lz1 = 0;
        swap(l, r);
        swap(tr[l].lf, tr[l].rt);
        swap(tr[r].lf, tr[r].rt);
        tr[l].lz1 ^= 1;
        tr[r].lz1 ^= 1;
    }
    if(tr[x].lz2){
        tr[x].lz2 = 0;
        GG(l, tr[x].val);
        GG(r, tr[x].val);
    }
}
int build(int ll, int rr){
    if(ll > rr) return 0;
    int x = sta[top--];
    tr[x].init(c[ll]);
    tr[x].son[1] = build(ll+1, rr);
    tr[tr[x].son[1]].pre = x;
    Push_Up(x);
    return x;
}
char s[50];

void rotate(int x){
    int y = tr[x].pre;
    int z = tr[y].pre;
    int k = tr[y].son[1] == x;
    tr[x].pre = z;
    tr[z].son[y == tr[z].son[1]] = x;
    tr[y].son[k] = tr[x].son[k^1];
    tr[tr[x].son[k^1]].pre = y;
    tr[y].pre = x;
    tr[x].son[k^1] = y;
    Push_Up(y);
}
void Splay(int x, int goal){
    Push_Down(x);
    while(tr[x].pre != goal){
        int y = tr[x].pre;
        int z = tr[y].pre;
        if(z != goal){
            if((tr[y].son[0] == x) ^ (tr[z].son[0] ==  y)) rotate(x);
            else rotate(y);
        }
        rotate(x);
    }
    if(!goal) root = x;
    Push_Up(x);
}
int Find(int x, int p){
    Push_Down(p);
    int &l = tr[p].son[0], &r = tr[p].son[1];
    if(x == tr[l].sz + 1) return p;
    if(x <= tr[l].sz) return Find(x, l);
    return Find(x - tr[l].sz - 1, r);
}
void Insert(int l, int num){
    int tt = build(1, num);
    int pl = Find(l+1, root);
    int pr = Find(l+2, root);
    Splay(pr, 0);
    Splay(pl, pr);
    tr[pl].son[1] = tt;
    tr[tt].pre = pl;
    Push_Up(pl);
    Push_Up(pr);
}
void Clear(int x){
    if(tr[x].son[0]) Clear(tr[x].son[0]);
    if(tr[x].son[1]) Clear(tr[x].son[1]);
    sta[++top] = x;
}
void Delete(int l, int r){
    int pl = Find(l, root);
    int pr = Find(r+2, root);
    Splay(pl, 0);
    Splay(pr, pl);
    Clear(tr[pr].son[0]);
    tr[pr].son[0] = 0;
    Push_Up(pr);
    Push_Up(pl);
}

void Make_same(int l, int r, int v){
    int pl = Find(l, root);
    int pr = Find(r+2, root);
    Splay(pl, 0);
    Splay(pr, pl);
    GG(tr[pr].son[0], v);
    int t = tr[pr].son[0];
    Push_Up(pr);
    Push_Up(pl);
}
void Reverse(int l, int r){
    int pl = Find(l, root);
    int pr = Find(r+2, root);
    Splay(pl, 0);
    Splay(pr, pl);
    tr[tr[pr].son[0]].lz1 ^= 1;
    Push_Down(tr[pr].son[0]);
    Push_Up(tr[pr].son[0]);
    Push_Up(pr);
    Push_Up(pl);
}
int Get_sum(int l, int r){
    int pl = Find(l, root);
    int pr = Find(r+2, root);
    Splay(pl, 0);
    Splay(pr, pl);
    return tr[tr[pr].son[0]].sum;
}
int Max_sum(){
    if(tr[root].maxx < 0) return tr[root].maxx;
    return tr[root].ma;
}
int main(){
    for(int i = N-50; i > 0; i--) sta[++top] = i;
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++) scanf("%d", &c[i]);
    c[0] = c[n+1] = -inf;
    tr[0].maxx = tr[0].val = -inf;
    root = build(0, n+1);
    int l, r, t;
    while(m--){
        scanf("%s", s);
        if(s[0] == 'I'){
            scanf("%d%d", &l, &r);
            for(int i = 1; i <= r; i++) scanf("%d", &c[i]);
            Insert(l,r);
        }
        else if(s[0] == 'D'){
            scanf("%d%d", &l, &r);
            Delete(l, l+r-1);
        }
        else if(s[2] == 'K'){
            scanf("%d%d%d", &l, &r, &t);
            Make_same(l, l+r-1, t);
        }
        else if(s[0] == 'R'){
            scanf("%d%d", &l, &r);
            Reverse(l, l+r-1);
        }
        else if(s[0] == 'G'){
            scanf("%d%d", &l, &r);
            printf("%d
", Get_sum(l, l+r-1));
        }
        else {
            printf("%d
", Max_sum());
        }
    }
    return 0;
}