bzoj1500 noi2005 维修数列

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;}
}
}
}