bzoj1500 noi2005 维修数列

最新推荐文章于 2019-07-04 22:58:56 发布

原创最新推荐文章于 2019-07-04 22:58:56 发布 · 461 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#平衡树

数据结构专栏收录该内容

10 篇文章

订阅专栏

本文提供了一种使用非旋转treap解决NOI2005维修数列问题的方法，通过实现split、merge等操作，有效地处理了数列的插入、删除、求和等操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1500: [NOI2005]维修数列

Time Limit: 10 Sec Memory Limit: 64 MB
Submit: 15855 Solved: 5269
[ Submit][ Status][ Discuss]

Description

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

Source

[ Submit][ Status][ Discuss] 先说下我做这道题的感受吧，真的没有啥思维难度，那个最大连续和的分治dp能学到平衡树也都能懂吧。。这个题最大的问题就是代码实现了。为了肛这个题，我花费了三个晚上大概6h的时间，其中写2h，调4h。我使用非旋转treap写的此题，（主要是因为splay的rotate容易写错才没写（ ~~实际上是不会~~）），非旋转treap除了实现lct不如splay以外，其他方面似乎都能胜过splay，最大特色是可持久化，常数基本和splay持平，编写难度小，理解难度大于splay，理解之后代码极其好写，极其直观，它凭借3个操作来完成所有的询问： 1：merge，把两个treap合并成一个； 2：split，把一个treap按前k位（或是比k小的数）划分成两个，剩下部分就是剩余的treap； 3：build，建立一棵treap，使用笛卡尔树可以将复杂度降到O（n），笛卡尔树： 笛卡尔树 - 农民伯伯-Coding - 博客园。所以自然而然就能知道每一个修改或者询问的写法了，具体请见代码，代码有详细注释。

#include <cstdio>
#include <iostream>
#include <queue>
using namespace std;
char t[15];
int pos,tot,ai,n,m,seed=537;
inline int read()
{
    int ans=0,f=1;
    char c=getchar();
    while(c<'0'||c>'9')
    {
        if(c=='-') f=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9')
    {
        ans=ans*10+c-'0';
        c=getchar();
    }
    return ans*f;
}
int myrand()
{
    seed=(seed*383*233+1926081700)%2147483647;
    return seed;
}
struct nod
{
    nod *l,*r;
    int pri,val,siz,sum,lazflip,lazval,ls,rs,ms;
    nod(){pri=myrand(),val=ls=rs=ms=-1000000000;sum=lazflip=lazval=siz=0;};
    void update()
    {
        siz=l->siz+r->siz+1;
        sum=l->sum+r->sum+val;
        ls=max(l->ls,max(l->sum+val,l->sum+val+r->ls));//1.原值 2.左子树和+当前权值 3.左子树和+当前权值+右子树前缀最大连续和
        rs=max(r->rs,max(r->sum+val,r->sum+val+l->rs));//对称
        ms=max(max(l->ms,r->ms),max(0,l->rs)+max(0,r->ls)+val);//1.左子树 2.右子树 3.左子树后缀+当前权值+右子树前缀
    }
}*null=new nod(),*root=null,*S[500005],*x=null,*last=null;//空节点 根 笛卡尔树栈
queue<nod*>q;
typedef pair<nod*,nod*> pnn;
void maintainflip(nod *a)
{
    if(a==null) return;
    a->lazflip^=1;//改变标记
    swap(a->ls,a->rs);//翻转序列之后 前缀后缀最大和也要颠倒
}
void maintainval(nod *a,int c)
{
    if(a==null) return;
    a->val=a->lazval=c;//更新权值
    a->sum=a->siz*c;//更新和
    a->ls=a->rs=a->ms=max(a->siz*c,c);//现在全序列都是c 所以只有两种选择
}
void down(nod *a)//下传标记
{
    if(a==null) return;
    if(a->lazflip)
    {
        a->lazflip^=1;
        maintainflip(a->l);
        maintainflip(a->r);
        swap(a->l,a->r);
    }
    if(a->lazval!=2147483647)
    {
        a->lazval=2147483647;
        maintainval(a->l,a->val);
        maintainval(a->r,a->val);
    }
}
nod *merge(nod* a,nod* b)//把两个treap合并成一个
{
    if(a==null) return b;
    if(b==null) return a;
    else if(a->pri<b->pri)//左边优先级小 向左合并
    {
        down(a);
        a->r=merge(a->r,b);
        a->update();
        return a;
    }
    else//否则向右边合并
    {
        down(b);
        b->l=merge(a,b->l);
        b->update();
        return b;
    }
}
pnn spilt(nod* a,int k)//把一个treap分裂成前k位和剩余部分，返回两个根
{
    if(a==null) return pnn(null,null);
    down(a);
    pnn b;
    if(a->l->siz>=k)//在左子树分裂
    {
        b=spilt(a->l,k);
        a->l=b.second;
        a->update();//更新，再赋回来
        b.second=a;
    }
    else
    {//对称情况
        b=spilt(a->r,k-a->l->siz-1);
        a->r=b.first;
        a->update();
        b.first=a;
    }
    return b;
}
nod *newnod(int a)//根据权值创建一棵新节点
{
    nod *x=q.front();
    q.pop();
    x->ls=x->rs=x->ms=x->val=x->sum=a;
    x->l=x->r=null;
    x->pri=myrand();
    x->siz=1;
    x->lazval=2147483647;
    x->lazflip=0;
    return x;
}
nod *build()//建造一棵笛卡尔树
{
    int cur=0;
    for(int i=1;i<=n;i++)
    {
        int a=read();
        x=newnod(a);
        last=null;
        while(cur&&S[cur]->pri>x->pri)//找到一个可以插入的位置，即优先级在父亲和儿子之间
        {
            S[cur]->update();//更新权值
            last=S[cur];//记录上一个儿子
            S[cur--]=null;//退栈
        }
        if(cur) S[cur]->r=x;//在找好的位置的右子树加节点 他的左子树是上一个儿子
        x->l=last;
        S[++cur]=x;//此节点入栈
    }
    while(cur) S[cur--]->update();//要更新完毕
    return S[1];//返回根
}
void free(nod* x)//删除以x为根的节点并释放内存
{
    if(x==null) return;
    if(x->l!=null) free(x->l);
    if(x->r!=null) free(x->r);
    q.push(x);
}
void insert()//插入一个序列
{
    int pos=read();n=read();
    nod *a=build();
    pnn b=spilt(root,pos);
    root=merge(merge(b.first,a),b.second);
}
void Delete()//删除一个序列
{
    int pos=read();n=read();
    pnn a=spilt(root,pos-1),b=spilt(a.second,n);
    free(b.first);
    root=merge(a.first,b.second);
}
void make_same()//把一段序列统一赋一个值
{
    int pos=read();n=read();int c=read();
    pnn a=spilt(root,pos-1),b=spilt(a.second,n);
    maintainval(b.first,c);
    root=merge(a.first,merge(b.first,b.second));
}
void reverse()//翻转一段序列
{
    int pos=read();n=read();
    pnn a=spilt(root,pos-1),b=spilt(a.second,n);
    maintainflip(b.first);
    root=merge(a.first,merge(b.first,b.second));
}
void get_sum()//求一段序列的和
{
    int pos=read();n=read();
    pnn a=spilt(root,pos-1),b=spilt(a.second,n);
    printf("%d\n",b.first->sum);
    root=merge(a.first,merge(b.first,b.second));
}
void max_sum()//求整个序列的最大连续和
{
    printf("%d\n",root->ms);
}
int main()
{
    n=read();m=read();
    for(int i=1;i<=500000;i++) q.push(new nod());
    root=build();
    for(int i=1;i<=m;i++)
    {
        scanf("%s",t);
        switch(t[0])
        {
            case 'I':{insert();break;}
            case 'D':{Delete();break;}
            case 'M':
            {
                if(t[2]=='K'){make_same();break;}
                else {max_sum();break;}
            }
            case 'R':{reverse();break;}
            case 'G':{get_sum();break;}
        }
    }
}