NOI2005 维修数列 SPLAY各种操作

最新推荐文章于 2026-05-07 16:31:05 发布

原创最新推荐文章于 2026-05-07 16:31:05 发布 · 1.1k 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

splay 专栏收录该内容

11 篇文章

订阅专栏

本文详细解析了NOI2005维修数列问题，通过使用线段树维护最大子序列和的方法，实现了对数列的插入、删除、修改、翻转等操作，并分享了在实现过程中遇到的内存回收问题。

太冤了，DEBUG了一天，原本打算通宵了，没想到突然发现回收整个子树的函数del（x）被我写成了delnode（x）【删除单个节点】，结果TLE了一天，大概交了30多次。。其实就是MLE了。。。。。。好怨啊。。。。。

题目的思路很清晰

比较不同的就是最大子序列和的处理方法，以前做过一道线段树，这题其实也一样维护三个值。

插入在第i个数字后面插入n个数方法是在区间[i,i+1]之间插入一颗已经构造好的完全二叉

删除删除第i个数字开始的n个数子旋转得到区间[i,i+n-1] 删除之
修改将区间[i,i+n-1]全部变成k
翻转翻转区间[i,i+n-1];
求和求区间[i,i+n-1] ;
求最大子序列和每一个区间维护三个值 1 从左边开始的最大值 sl 2 从右边开始的最大值 sr 3 区间上的最大值 sm,然后和线段树一样处理

左子树 l 右子树 r 整个区间所有数的和 sum

一个区间从左边开始的最大值 = （l.sl , l.sum+key , l.sum+key+r.sl）

一个区间从右边开始的最大值 = （r.sr , r.sum+key , r.sum+key+l.sr）

一个区间的最大子序列和= (l.sm ,r.sm ,key , l.sr+key+r.sl , l.sr+key , key+r.sl)

这道题的困难之处在于，我们要维护一个区间上面的三个值，这里要注意我们push_down的时候一定要把左右子树的root更新，否则这个值会影响到push_up的操作。

PS：注意回收内存。

1500: [NOI2005]维修数列

Time Limit: 10 Sec Memory Limit: 64 MB
Submit: 3582 Solved: 1089
[ Submit][ Status][ Discuss]

Description

Input

输入文件的第1行包含两个数N和M，N表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，描述初始时的数列。以下M行，每行一条命令，格式参见问题描述中的表格。

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

#include<iostream>
#include<cstring>
#include<algorithm>
#include<string>
#include<cstdio>


using namespace std;

#define MAXN 505050
#define INF  0x3FFFFFf

int next[MAXN];
int a[MAXN];

struct nodes
{
    int ch[2],f;
    int key,size,w,col,sum;
    int maxl,maxr,maxm;
    int same;
}node[MAXN];

void init()
{
    for(int i=0;i<MAXN-10;i++)
        next[i]=i+1;
}

inline int newnode(int key)
{
    int p=next[0];
    next[0]=next[p];
    node[p].key=key;
    node[p].w=node[p].size=1;
    node[p].col=node[p].same=0;
    node[p].maxl=node[p].maxm=node[p].sum=node[p].maxr=key;
    node[p].ch[0]=node[p].ch[1]=node[p].f=0;
    return p;
}

inline void delnode(int p)
{
    next[p]=next[0];
    next[0]=p;
}

struct spt
{
    int root;
    void clear()
    {
        root=0;
    }
    void rotate(int x,int c)
    {
        int y=node[x].f;
        push_down(y);push_down(x);
        node[y].ch[!c]=node[x].ch[c];
        if(node[x].ch[c])
                node[node[x].ch[c]].f=y;
        node[x].f=node[y].f;
        if(node[y].f)
        {
            if(node[node[y].f].ch[0]==y)
                node[node[y].f].ch[0]=x;
            else
                node[node[y].f].ch[1]=x;
        }
        node[x].ch[c]=y;
        node[y].f=x;
        push_up(y);
        if(y==root) root=x;
    }
    void splay(int x,int f)
    {
        push_down(x);
        for(;node[x].f!=f;)
        {
            if(node[node[x].f].f==f)
            {
                if(node[node[x].f].ch[0]==x)
                    rotate(x,1);
                else
                    rotate(x,0);
            }
            else
            {
                int y=node[x].f;
                int z=node[y].f;
                if(node[z].ch[0]==y)
                {
                    if(node[y].ch[0]==x)
                        rotate(y,1),rotate(x,1);
                    else
                        rotate(x,0),rotate(x,1);
                }
                else
                {
                    if(node[y].ch[1]==x)
                        rotate(y,0),rotate(x,0);
                    else
                        rotate(x,1),rotate(x,0);
                }
            }
        }
        push_up(x);
        if(!f) root=x;
    }
    void remove(int l,int r)
    {
        select(l,0);
        select(r+2,root);
        int p=node[root].ch[1];
        int x=node[p].ch[0];
        node[p].ch[0]=0;
        push_up(p);
        push_up(root);
        del(x);

    }
    void reverse(int l,int r)
    {
        select(l,0);
        select(r+2,root);
        update_rev(node[node[root].ch[1]].ch[0]);
    }
    void mksame(int l,int r,int key)
    {
        int ll=getkth(root,l);
        splay(ll,0);
        int rr=getkth(root,r+2);
        splay(rr,root);
        update_same(node[node[root].ch[1]].ch[0],key);
        push_up(node[root].ch[1]);
        push_up(root);
    }
    int getkth(int r,int k)
    {
        push_down(r);
        int t=node[node[r].ch[0]].size+1;
        if(t==k)
            return r;
        if(t>k)
            return getkth(node[r].ch[0],k);
        else
            return getkth(node[r].ch[1],k-t);
    }
    int select(int k,int rt)
    {
        int tmp,t=root;
        push_down(t);
        for(;;)
        {
            int l=node[node[t].ch[0]].size;
            if(k>l && k<=l+node[t].w) break;
            if(k<=l)
                t=node[t].ch[0];
            else
                k-=(l+node[t].w),t=node[t].ch[1];
            push_down(t);
        }
        splay(t,rt);
        return t;
    }
    int getmin(int p)
    {
        push_down(p);
        while(node[p].ch[0])
        {
            p=node[p].ch[0];
            push_down(p);
        }
        return p;
    }
    int getmaxn(int p)
    {
        push_down(p);
        while(node[p].ch[1])
        {
            p=node[p].ch[1];
            push_down(p);
        }
        return p;
    }
    int insert(int s1,int s2)
    {
        select(s1+1,0);
        int p=getmin(node[root].ch[1]);
        splay(p,root);
        node[p].ch[0]=build(1,s2,p);
        push_up(node[root].ch[1]);
        push_up(root);
    }
    int getmaxsum(int l,int r)
    {
        select(l,0);
        select(r+2,root);
        return node[node[node[root].ch[1]].ch[0]].maxm;
    }
    int getsum(int l,int r)
    {
        select(l,0);
        select(r+2,root);
        return node[node[node[root].ch[1]].ch[0]].sum;
    }

    void push_up(int rt)
    {
        if(!rt)return;
        int l=node[rt].ch[0];
        int r=node[rt].ch[1];
        node[rt].size=node[l].size+node[r].size+node[rt].w;
        node[rt].sum=node[l].sum+node[r].sum+node[rt].key;
        node[rt].maxl=max(node[l].maxl,node[l].sum+node[rt].key+max(0,node[r].maxl));
        node[rt].maxr=max(node[r].maxr,node[r].sum+node[rt].key+max(0,node[l].maxr));
        node[rt].maxm=max(node[l].maxr,0)+node[rt].key+max(0,node[r].maxl);
        node[rt].maxm=max(node[rt].maxm,max(node[l].maxm,node[r].maxm));
    }
    void push_down(int rt)
    {
        if(rt && node[rt].col)
        {
            update_rev(node[rt].ch[0]);
            update_rev(node[rt].ch[1]);
            node[rt].col=0;
        }
        if(rt && node[rt].same)
        {
            update_same(node[rt].ch[0],node[rt].key);
            update_same(node[rt].ch[1],node[rt].key);
            node[rt].same=0;
        }
    }
    void del(int p)
    {
        if(!p) return;
        del(node[p].ch[0]);
        del(node[p].ch[1]);
        delnode(p);
    }

    int build(int l,int r,int f)
    {

        if(l>r) return 0;
        int m=(l+r)>>1;
        int p=newnode(a[m]);
        node[p].f=f;
        node[p].ch[0]=build(l,m-1,p);
        node[p].ch[1]=build(m+1,r,p);
        push_up(p);
        return p;
    }

    void update_same(int x,int k)
    {
        if(!x) return;
        node[x].same=1;
        node[x].key=k;
        node[x].sum=node[x].size*k;
        node[x].maxl=node[x].maxr=node[x].maxm=max(k,node[x].sum);
    }

    void update_rev(int x)
    {
        if(!x) return;
        swap(node[x].ch[0],node[x].ch[1]);
        swap(node[x].maxl,node[x].maxr);
        node[x].col^=1;
    }

};

spt s1,s2;
int n,m;

void prepare()
{
    s1.clear();
    node[0].sum=node[0].size=0;
    node[0].key=node[0].maxl=node[0].maxm=node[0].maxr=-INF;
    s1.root=newnode(0);
    node[s1.root].ch[1]=newnode(0);
    node[node[s1.root].ch[1]].f=s1.root;
    node[node[s1.root].ch[1]].ch[0]=s1.build(1,n,node[s1.root].ch[1]);
    s1.push_up(node[s1.root].ch[1]);
    s1.push_up(s1.root);
}

char q[50];

int main()
{
    int l,r,key,p,tot;
    init();
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        prepare();
        for(int i=0;i<m;i++)
        {
           scanf("%s",q);
           if(q[0]=='I')
           {
               scanf("%d%d",&p,&tot);
               for(int j=1;j<=tot;j++) scanf("%d",&a[j]);
               s1.insert(p,tot);
           }
           else if(q[0]=='D')
           {
               scanf("%d%d",&l,&r);
               s1.remove(l,l+r-1);
           }
           else if(q[0]=='R')
           {
               scanf("%d%d",&l,&r);
               s1.reverse(l,l+r-1);
           }
           else if(q[0]=='G')
           {
               scanf("%d%d",&l,&r);
               s1.select(l,0);
               s1.select(l+r+1,s1.root);
               if(r==0)
                    printf("0\n");
               else
               printf("%d\n",node[node[node[s1.root].ch[1]].ch[0]].sum);
           }
           else if(strcmp("MAKE-SAME",q)==0)
           {
               scanf("%d%d%d",&l,&r,&key);
               s1.mksame(l,l+r-1,key);
           }
           else
               printf("%d\n",s1.getmaxsum(1,node[s1.root].size-2));
        }
        s1.del(s1.root);
    }
    return 0;
}