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

[Submit][Status][Discuss]

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

 

题解：Splay tree模板题；

自己的板子：

#include<bits/stdc++.h>
#define RI register int
#define For(i,a,b) for (RI i=a;i<=b;++i)
using namespace std;
const int inf=0x3f3f3f3f;
const int N=1e6+17;
int n,m,rt,cnt;
int a[N],id[N],fa[N],c[N][2];
int sum[N],sz[N],v[N],mx[N],lx[N],rx[N];
bool tag[N],rev[N];
//tag表示是否有统一修改的标记，rev表示是否有统一翻转的标记
//sum表示这个点的子树中的权值和，v表示这个点的权值
//lx[]是一个子树以最左端为起点向右延伸的最大子串和,rx类似 
//mx[]是当前子树的最大子串和
queue<int> q;
inline int read()
{
    RI x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-') f=-1; ch=getchar();}
    while('0'<=ch&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
    return x*f;
}
inline void pushup(RI x)
{
    RI l=c[x][0],r=c[x][1];
    sum[x]=sum[l]+sum[r]+v[x];
    sz[x]=sz[l]+sz[r]+1;
    mx[x]=max(mx[l],max(mx[r],rx[l]+v[x]+lx[r]));
    lx[x]=max(lx[l],sum[l]+v[x]+lx[r]);
    rx[x]=max(rx[r],sum[r]+v[x]+rx[l]);
}
//上传记录标记
inline void pushdown(RI x)
{
    RI l=c[x][0],r=c[x][1];
    if(tag[x])
    {
        rev[x]=tag[x]=0;//我们有了一个统一修改的标记，再翻转就没有什么意义了
        if(l) tag[l]=1,v[l]=v[x],sum[l]=v[x]*sz[l];
        if(r) tag[r]=1,v[r]=v[x],sum[r]=v[x]*sz[r];
        if(v[x]>=0) 
        {
            if(l) lx[l]=rx[l]=mx[l]=sum[l];
            if(r) lx[r]=rx[r]=mx[r]=sum[r];
        }
        else
        {
            if(l) lx[l]=rx[l]=0,mx[l]=v[x];
            if(r) lx[r]=rx[r]=0,mx[r]=v[x];
        }
    }
    if(rev[x])
    {
        rev[x]=0;rev[l]^=1;rev[r]^=1;
        swap(lx[l],rx[l]);swap(lx[r],rx[r]);
        //注意,在翻转操作中,前后缀的最大和子序列都反过来了 
        swap(c[l][0],c[l][1]);swap(c[r][0],c[r][1]);
    }
}
inline void rotate(RI x,RI &k)
{
    RI y=fa[x],z=fa[y],l=(c[y][1]==x),r=l^1;
    if (y==k)k=x;else c[z][c[z][1]==y]=x;
    fa[c[x][r]]=y;fa[y]=x;fa[x]=z;
    c[y][l]=c[x][r];c[x][r]=y;
    pushup(y);pushup(x);
    //旋转操作,一定要上传标记且顺序不能变 
}
inline void splay(RI x,RI &k)
{
    while(x!=k)
    {
        int y=fa[x],z=fa[y];
        if(y!=k)
        {
            if((c[z][0]==y)^(c[y][0]==x)) rotate(x,k);
            else rotate(y,k);
        }
        rotate(x,k);
    }
}
//这是整个程序的核心之一，毕竟是伸展操作嘛
inline int find(RI x,RI rk)
{//返回当前序列第rk个数的标号 
    pushdown(x);
    RI l=c[x][0],r=c[x][1];
    if(sz[l]+1==rk) return x;
    if(sz[l]>=rk) return find(l,rk);
    else return find(r,rk-sz[l]-1);
}
inline void recycle(RI x)
{//这就是用时间换空间的回收冗余编号机制，很好理解
    RI &l=c[x][0],&r=c[x][1];
    if(l) recycle(l);
    if(r) recycle(r);
    q.push(x);
    fa[x]=l=r=tag[x]=rev[x]=0;
}
inline int split(RI k,RI tot)//找到[k+1,k+tot]
{
    RI x=find(rt,k),y=find(rt,k+tot+1);
    splay(x,rt);splay(y,c[x][1]);
    return c[y][0];
}
//这个split操作是整个程序的核心之三
//我们通过这个split操作，找到[k+1,k+tot]，并把k,和k+tot+1移到根和右儿子的位置
//然后我们返回了这个右儿子的左儿子，这就是我们需要操作的区间
inline void query(RI k,RI tot)
{
    RI x=split(k,tot);
    printf("%d\n",sum[x]);
}
inline void modify(RI k,RI tot,RI val)//MAKE-SAME
{
    RI x=split(k,tot),y=fa[x];
    v[x]=val;tag[x]=1;sum[x]=sz[x]*val;
    if(val>=0) lx[x]=rx[x]=mx[x]=sum[x];
        else lx[x]=rx[x]=0,mx[x]=val;
    pushup(y);pushup(fa[y]);
    //每一步的修改操作，由于父子关系发生改变
    //及记录标记发生改变，我们需要及时上传记录标记
}
inline void rever(RI k,RI tot)//翻转 
{
    RI x=split(k,tot),y=fa[x];
    if(!tag[x])
    {
        rev[x]^=1;
        swap(c[x][0],c[x][1]);
        swap(lx[x],rx[x]);
        pushup(y);pushup(fa[y]);
    }
    //同上
}
inline void erase(RI k,RI tot)//DELETE
{
    RI x=split(k,tot),y=fa[x];
    recycle(x);c[y][0]=0;
    pushup(y);pushup(fa[y]);
    //同上
}
inline void build(RI l,RI r,RI f)
{
    RI mid=(l+r)>>1,now=id[mid],pre=id[f];
    if(l==r)
    {
        mx[now]=sum[now]=a[l];
        tag[now]=rev[now]=0;
        //这里这个tag和rev的清0是必要，因为这个编号可能是之前冗余了
        lx[now]=rx[now]=max(a[l],0);
        sz[now]=1;
    }
    if(l<mid) build(l,mid-1,mid);
    if(mid<r) build(mid+1,r,mid);
    v[now]=a[mid]; fa[now]=pre;
    pushup(now); //上传记录标记
    c[pre][mid>=f]=now;
    //当mid>=f时，now是插入到又区间取了，所以c[pre][1]=now，当mid<f时同理
}
inline void insert(RI k,RI tot)
{
    for(int i=1;i<=tot;++i) a[i]=read();
    for(int i=1;i<=tot;++i)
    {
        if(!q.empty()) id[i]=q.front(),q.pop();
        else id[i]=++cnt;//利用队列中记录的冗余节点编号
    }
    build(1,tot,0);
    RI z=id[(1+tot)>>1];
    RI x=find(rt,k+1),y=find(rt,k+2);
     //首先，依据中序遍历，找到我们需要操作的区间的实际编号
    splay(x,rt);splay(y,c[x][1]);
    //把k+1(注意我们已经右移了一个单位）和(k+1)+1移到根和右儿子
    fa[z]=y;c[y][0]=z;
    //直接把需要插入的这个平衡树挂到右儿子的左儿子上去就好了
    pushup(y);pushup(x);
    //上传记录标记
}
//可以这么记，只要用了split就要重新上传标记
//只有find中需要下传标记
int main()
{
    n=read(),m=read();
    mx[0]=a[1]=a[n+2]=-inf;
    For(i,1,n) a[i+1]=read();
    For(i,1,n+2) id[i]=i;//虚拟了两个节点1和n+2，然后把需要操作区间整体右移一个单位
    build(1,n+2,0);//建树
    rt=(n+3)>>1;cnt=n+2;//取最中间的为根
    RI k,tot,val;char ch[10];
    while(m--)
    {
        scanf("%s",ch);
        if(ch[0]!='M' || ch[2]!='X') k=read(),tot=read();
        if(ch[0]=='I') insert(k,tot);
        if(ch[0]=='D') erase(k,tot);//DELETE
        if(ch[0]=='M')
        {
            if(ch[2]=='X') printf("%d\n",mx[rt]);//MAX-SUM
            else val=read(),modify(k,tot,val);//MAKE-SAME
        }
        if(ch[0]=='R') rever(k,tot);//翻转 
        if(ch[0]=='G') query(k,tot);//GET-SUM
    }
    return 0;
}

 

 

斌神的板子

/**************************************************************
    Problem: 1500
    User: SongHL
    Language: C++
    Result: Accepted
    Time:6152 ms
    Memory:26684 kb
****************************************************************/
 
#include<bits/stdc++.h>
using namespace std;
 
#define Key_value ch[ch[root][1]][0]
const int MAXN = 500010;
const int INF = 0x3f3f3f3f;
int pre[MAXN],ch[MAXN][2],key[MAXN],size[MAXN];
int root,tot1;
int sum[MAXN],rev[MAXN],same[MAXN];
int lx[MAXN],rx[MAXN],mx[MAXN];
int s[MAXN],tot2;//内存池和容量
int a[MAXN];
int n,q;
 
void NewNode(int &r,int father,int k)
{
    if(tot2) r = s[tot2--];//取的时候是tot2--,存的时候就是++tot2
    else r = ++tot1;
    pre[r] = father;
    ch[r][0] = ch[r][1] = 0;
    key[r] = k;
    sum[r] = k;
    rev[r] = same[r] = 0;
    lx[r] = rx[r] = mx[r] = k;
    size[r] = 1;
}
void Update_Rev(int r)
{
    if(!r)return;
    swap(ch[r][0],ch[r][1]);
    swap(lx[r],rx[r]);
    rev[r] ^= 1;
}
void Update_Same(int r,int v)
{
    if(!r)return;
    key[r] = v;
    sum[r] = v*size[r];
    lx[r] = rx[r] = mx[r] = max(v,v*size[r]);
    same[r] = 1;
}
void push_up(int r)
{
    int lson = ch[r][0], rson = ch[r][1];
    size[r] = size[lson] + size[rson] + 1;
    sum[r] = sum[lson] + sum[rson] + key[r];
    lx[r] = max(lx[lson],sum[lson] + key[r] + max(0,lx[rson]));
    rx[r] = max(rx[rson],sum[rson] + key[r] + max(0,rx[lson]));
    mx[r] = max(0,rx[lson]) + key[r] + max(0,lx[rson]);
    mx[r] = max(mx[r],max(mx[lson],mx[rson]));
}
void push_down(int r)
{
    if(same[r])
    {
        Update_Same(ch[r][0],key[r]);
        Update_Same(ch[r][1],key[r]);
        same[r] = 0;
    }
    if(rev[r])
    {
        Update_Rev(ch[r][0]);
        Update_Rev(ch[r][1]);
        rev[r] = 0;
    }
}
void Build(int &x,int l,int r,int father)
{
    if(l > r)return;
    int mid = (l+r)/2;
    NewNode(x,father,a[mid]);
    Build(ch[x][0],l,mid-1,x);
    Build(ch[x][1],mid+1,r,x);
    push_up(x);
}
void Init()
{
    root = tot1 = tot2 = 0;
    ch[root][0] = ch[root][1] = size[root] = pre[root] = 0;
    same[root] = rev[root] = sum[root] = key[root] = 0;
    lx[root] = rx[root] = mx[root] = -INF;
    NewNode(root,0,-1);
    NewNode(ch[root][1],root,-1);
    for(int i = 0;i < n;i++)
        scanf("%d",&a[i]);
    Build(Key_value,0,n-1,ch[root][1]);
    push_up(ch[root][1]);
    push_up(root);
}
//旋转,0为左旋，1为右旋
void Rotate(int x,int kind)
{
    int y = pre[x];
    push_down(y);
    push_down(x);
    ch[y][!kind] = ch[x][kind];
    pre[ch[x][kind]] = y;
    if(pre[y])
        ch[pre[y]][ch[pre[y]][1]==y] = x;
    pre[x] = pre[y];
    ch[x][kind] = y;
    pre[y] = x;
    push_up(y);
}
//Splay调整，将r结点调整到goal下面
void Splay(int r,int goal)
{
    push_down(r);
    while(pre[r] != goal)
    {
        if(pre[pre[r]] == goal)
        {
            push_down(pre[r]);
            push_down(r);
            Rotate(r,ch[pre[r]][0] == r);
        }
        else
        {
            push_down(pre[pre[r]]);
            push_down(pre[r]);
            push_down(r);
            int y = pre[r];
            int kind = ch[pre[y]][0]==y;
            if(ch[y][kind] == r)
            {
                Rotate(r,!kind);
                Rotate(r,kind);
            }
            else
            {
                Rotate(y,kind);
                Rotate(r,kind);
            }
        }
    }
    push_up(r);
    if(goal == 0) root = r;
}
int Get_kth(int r,int k)
{
    push_down(r);
    int t = size[ch[r][0]] + 1;
    if(t == k)return r;
    if(t > k)return Get_kth(ch[r][0],k);
    else return Get_kth(ch[r][1],k-t);
}
 
//在第pos个数后面插入tot个数
void Insert(int pos,int tot)
{
    for(int i = 0;i < tot;i++)scanf("%d",&a[i]);
    Splay(Get_kth(root,pos+1),0);
    Splay(Get_kth(root,pos+2),root);
    Build(Key_value,0,tot-1,ch[root][1]);
    push_up(ch[root][1]);
    push_up(root);
}
 
//删除子树
void erase(int r)
{
    if(!r)return;
    s[++tot2] = r;
    erase(ch[r][0]);
    erase(ch[r][1]);
}
//从第pos个数开始连续删除tot个数
void Delete(int pos,int tot)
{
    Splay(Get_kth(root,pos),0);
    Splay(Get_kth(root,pos+tot+1),root);
    erase(Key_value);
    pre[Key_value] = 0;
    Key_value = 0;
    push_up(ch[root][1]);
    push_up(root);
}
//将从第pos个数开始的连续的tot个数修改为c
void Make_Same(int pos,int tot,int c)
{
    Splay(Get_kth(root,pos),0);
    Splay(Get_kth(root,pos+tot+1),root);
    Update_Same(Key_value,c);
    push_up(ch[root][1]);
    push_up(root);
}
 
//将第pos个数开始的连续tot个数进行反转
void Reverse(int pos,int tot)
{
    Splay(Get_kth(root,pos),0);
    Splay(Get_kth(root,pos+tot+1),root);
    Update_Rev(Key_value);
    push_up(ch[root][1]);
    push_up(root);
}
//得到第pos个数开始的tot个数的和
int Get_Sum(int pos,int tot)
{
    Splay(Get_kth(root,pos),0);
    Splay(Get_kth(root,pos+tot+1),root);
    return sum[Key_value];
}
//得到第pos个数开始的tot个数中最大的子段和
int Get_MaxSum(int pos,int tot)
{
    Splay(Get_kth(root,pos),0);
    Splay(Get_kth(root,pos+tot+1),root);
    return mx[Key_value];
}
 
void InOrder(int r)
{
    if(!r)return;
    push_down(r);
    InOrder(ch[r][0]);
    printf("%d ",key[r]);
    InOrder(ch[r][1]);
}
 
 
 
int main()
{
     while(scanf("%d%d",&n,&q) == 2)   
    {
        Init();
        char op[20];
        int x,y,z;
        while(q--)
        {
            scanf("%s",op);
            if(strcmp(op,"INSERT") == 0)
            {
                scanf("%d%d",&x,&y);
                Insert(x,y);
            }
            else if(strcmp(op,"DELETE") == 0)
            {
                scanf("%d%d",&x,&y);
                Delete(x,y);
            }
            else if(strcmp(op,"MAKE-SAME") == 0)
            {
                scanf("%d%d%d",&x,&y,&z);
                Make_Same(x,y,z);
            }
            else if(strcmp(op,"REVERSE") == 0)
            {
                scanf("%d%d",&x,&y);
                Reverse(x,y);
            }
            else if(strcmp(op,"GET-SUM") == 0)
            {
                scanf("%d%d",&x,&y);
                printf("%d\n",Get_Sum(x,y));
            }
            else if(strcmp(op,"MAX-SUM") == 0)
                printf("%d\n",Get_MaxSum(1,size[root]-2));
        }
    }
    return 0;
}