BZOJ1500:[NOI2005]维修数列(Splay)

Description

请写一个程序，要求维护一个数列，支持以下 6 种操作：

请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格

Input

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

Output

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

Sample Input

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

Sample Output

-1
10
1
10

HINT

Solution

平衡树模板(呵
qtmd
注意插入后更新不能用splay函数……
因为可能插入的是0之类的然后splay就RE了
只能用两个update或者splay+特判

题目卡空间记得回收节点编号

Code

#include<iostream>
#include<cstring>
#include<cstdio>
#define N (500000+100)
using namespace std;

int Lmax[N],Rmax[N],Mmax[N],Sum[N],Cov[N],Rev[N];
int n,m,pos,tot,Root,a[N];
int stack[N],top,sz,k;
int Val[N],Size[N],Son[N][2],Father[N];
char opt[21];

int Get(int x) {return Son[Father[x]][1]==x;}
void Clear(int x) {stack[++top]=x; Cov[x]=Rev[x]=Sum[x]=Mmax[x]=Lmax[x]=Rmax[x]=Father[x]=Son[x][0]=Son[x][1]=Size[x]=Val[x]=0;}
int Getid() {if (!top) return ++sz; return stack[top--];}

void Update(int x)
{
    Sum[x]=Sum[Son[x][0]]+Sum[Son[x][1]]+Val[x];
    Size[x]=Size[Son[x][0]]+Size[Son[x][1]]+1;
    Mmax[x]=max(max(Mmax[Son[x][0]],Mmax[Son[x][1]]),Rmax[Son[x][0]]+Lmax[Son[x][1]]+Val[x]);
    Lmax[x]=max(Lmax[Son[x][0]],Sum[Son[x][0]]+Lmax[Son[x][1]]+Val[x]);
    Rmax[x]=max(Rmax[Son[x][1]],Sum[Son[x][1]]+Val[x]+Rmax[Son[x][0]]);
}

int Build(int l,int r,int fa)
{
    if (l>r) return 0;
    if (l==r)
    {
        int id=Getid();
        Val[id]=Sum[id]=Mmax[id]=a[l];
        Size[id]=1;
        Father[id]=fa;
        Lmax[id]=Rmax[id]=max(a[l],0);
        return id;
    }
    int mid=(l+r)>>1;
    int id=Getid();
    Son[id][0]=Build(l,mid-1,id);
    Son[id][1]=Build(mid+1,r,id);
    Father[id]=fa;
    Val[id]=a[mid];
    Update(id);
    return id;
}

void Pushdown(int x)
{
    int l=Son[x][0],r=Son[x][1];
    if(Cov[x])
    {
        Rev[x]=Cov[x]=0;
        if(l)Cov[l]=1,Val[l]=Val[x],Sum[l]=Val[x]*Size[l];
        if(r)Cov[r]=1,Val[r]=Val[x],Sum[r]=Val[x]*Size[r];
        if(Val[x]>=0)
        {
            if(l)Lmax[l]=Rmax[l]=Mmax[l]=Sum[l];
            if(r)Lmax[r]=Rmax[r]=Mmax[r]=Sum[r];
        }
        else 
        {
            if(l)Lmax[l]=Rmax[l]=0,Mmax[l]=Val[x];
            if(r)Lmax[r]=Rmax[r]=0,Mmax[r]=Val[x];
        }
    }
    if(Rev[x])
    {
        Rev[x]^=1;Rev[l]^=1;Rev[r]^=1;
        swap(Lmax[l],Rmax[l]);swap(Lmax[r],Rmax[r]);
        swap(Son[l][0],Son[l][1]);swap(Son[r][0],Son[r][1]);
    }
}

void Rotate(int x)
{
    int wh=Get(x);
    int fa=Father[x],fafa=Father[fa];
    Father[fa]=x; Son[fa][wh]=Son[x][wh^1];
    if (Son[fa][wh]) Father[Son[fa][wh]]=fa;
    Father[x]=fafa; Son[x][wh^1]=fa;
    if (fafa) Son[fafa][Son[fafa][1]==fa]=x;
    Update(fa);
    Update(x);
}

void Push(int x){if (x!=Root) Push(Father[x]); Pushdown(x);}
void Splay(int x,int tar)
{
    Push(x);
    for (int fa;(fa=Father[x])!=tar;Rotate(x))
        if (Father[fa]!=tar)
            Rotate(Get(fa)==Get(x)?fa:x);
    if (!tar) Root=x;
}

int Findx(int x)
{
    int now=Root;
    while (1)
    {
        Pushdown(now);
        if (Size[Son[now][0]]>=x)
            now=Son[now][0];
        else
        {
            x-=Size[Son[now][0]];
            if (x==1)
            {
                Splay(now,0);
                return now;
            }
            x--;
            now=Son[now][1];
        }
    }
}

int Split(int x,int y)
{
    int xx=Findx(x);
    int yy=Findx(y);
    Splay(xx,0); Splay(yy,xx);
    return Son[yy][0];
}

void Clear_up(int x)
{
    if (Son[x][0]) Clear_up(Son[x][0]);
    if (Son[x][1]) Clear_up(Son[x][1]);
    Clear(x);
}

void INSERT(int pos,int tot)
{
    Split(pos+1,pos+2);
    for (int i=1;i<=tot;++i)
        scanf("%d",&a[i]);
    int x=Build(1,tot,Son[Root][1]);
    Son[Son[Root][1]][0]=x;
    Update(Son[Root][1]); Update(Root);
}

void DELETE(int pos,int tot)
{
    int x=Split(pos,pos+tot+1);
    Son[Father[x]][Get(x)]=0;
    Clear_up(x);
    Update(Son[Root][1]); Update(Root);
}

void MAKE_SAME(int pos,int tot,int k)
{
    int x=Split(pos,pos+tot+1);
    Cov[x]=k;
    Val[x]=k; Cov[x]=1; Sum[x]=Size[x]*k;
    if(k>=0)Lmax[x]=Rmax[x]=Mmax[x]=Sum[x];
    else Lmax[x]=Rmax[x]=0,Mmax[x]=k;
    Update(Son[Root][1]); Update(Root);
}

void REVERSE(int pos,int tot)
{
    int x=Split(pos,pos+tot+1);
    Rev[x]^=1;
    swap(Son[x][0],Son[x][1]);
    swap(Lmax[x],Rmax[x]);
    Update(Son[Root][1]); Update(Root);
}

void GET_SUM(int pos,int tot)
{
    int x=Split(pos,pos+tot+1);
    printf("%d
",Sum[x]);
    Update(Son[Root][1]); Update(Root);
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;++i)
        scanf("%d",&a[i+1]);
    Mmax[0]=a[1]=a[n+2]=-0x3fffffff;
    Build(1,n+2,0);
    Root=1;
    while (m--)
    {
        scanf("%s",opt);
        if (opt[0]!='M' || opt[2]!='X') scanf("%d%d",&pos,&tot);
        if (opt[0]=='I') INSERT(pos,tot);
        if (opt[0]=='D') DELETE(pos,tot);
        if (opt[0]=='M')
        {
            if (opt[2]=='X') printf("%d
",Mmax[Root]);
            else scanf("%d",&k),MAKE_SAME(pos,tot,k);
        }
        if (opt[0]=='R')REVERSE(pos,tot);
        if (opt[0]=='G')GET_SUM(pos,tot);
    }
}