POJ3580[memo] 旋转吧,splay!

重新写了一下splay，并且琢磨自己的版。

以前看过这道题，感觉操作好繁琐，不做。

今天看了一下，恩，有必要再写一下splay，先拿这道题练手。

题意：

给定序列，维护6个操作：

ADD　ｌ　ｒ　ｘ　　把［ｌ，ｒ］加上ｘ

ＲＥＶＥＲＳＥ　ｌ　ｒ　　把［ｌ，ｒ］翻转

ＲＥＶＯＬＶＥ　ｌ　ｒ　ｔ　把［ｌ，ｒ］这一段向后滚动ｔ次，　　比如１,２,３　　滚动２次变成　　２,３,１

ＩＮＳＥＲＴ x y  在x后面插入y

DELTEL　ｘ删掉第ｘ个元素

ＭＩＮ　ｌ　ｒ　询问［ｌ，ｒ］中的最小值

对于第一个操作，用ｌａｚｙ标记维护ｐｕｓｈｄｏｗｎ一下就好了

对于第二个操作，用ｂｏｏｌ　型的ｒｅｖ维护ｐｕｓｈｄｏｗｎ一下就好了

第三个操作，先将ｔ对区间长度取ｍｏｄ，然后分成前面的区间和后ｔ个元素的区间，交换这两个区间的先后，我们可以先把两个区间分别翻转，再把整个区间翻转，这样影响的只是前后两个区间的位置，不影响里面的元素排列。

第四个操作，把ｘ旋到根，ｘ＋１旋到根的右儿子，ｒｏｏｔ－＞ｒ－＞ｌ一定为空，直接插入元素即可

第五个操作，把ｘ－１旋到根，ｘ＋１旋到根的右儿子，ｒｏｏｔ－＞ｒ－ｌ就是ｘ，删掉就好了

第６个，在ｓｐｌａｙ维护一个最小值，每次ｐｕｓｈｄｏｗｎ和ｒｏｔａｔｅ的时候更新一下，到时候照样的ｌ－１旋到根，ｒ＋１选到根的右边，查询ｒｏｏｔ－＞ｒ－ｌ即可。

ＰＳ：注意如果ｓｐｌａｙ单纯地维护［１，ｎ］，对于ｌ－１，ｒ＋１可能会越界，需要特判．

但是特判是在是麻烦，代码量增长不少，所以为了简便，我提前插入了０和ｎ＋１两个节点，之后涉及到区间的都把区间标号＋１　　

然后就没有了，我ｄｅｂｕｇ还是调了那么久，毕竟数据结构的题嘛，不过要比我想象的顺利一些。

ＰＳ被坑点：

１.ＤＥＬ之后将空节点选到了根（果断ＲＥ，都空了，咋旋）　　　

２.ＲＥＶＯＬＶＥ那里开始写的特别复杂，后来改成这样，不过把又把区间标号向右移了１，算上翻转那里又＋１，就把区间标号向右移了２次。

ｓｐｌａｙ的性质是，把操作过的点旋到根，这样在一种玄学的推理下单词查询复杂度降为均摊ｌｏｇｎ　．　　所以我把ｉｎｓｅｒｔ和ｍｉｎ涉及到的点旋到了根，应该会快些吧－　－

然后就附上代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<cmath>
using namespace std;
const int maxn=100000+20;
struct node
{
node *f;
node *ch[2];
int sz,key,m;//size key min
int lazy;//addd
bool rev;//reverse
void rs()
{
sz=1+ch[0]->sz+ch[1]->sz;
m=key;
m=min(m,ch[0]->m);
m=min(m,ch[1]->m);
}
}S[maxn<<2],*root,*null;
int ncnt;
int n,m;
void clear()
{
ncnt=0;
null=&S[ncnt];
null->sz=0;
null->key=0x3f3f3f3f;
null->m=0x3f3f3f3f;
null->lazy=null->rev=0;
root=null;
}
node *newnode(int key)
{
node *p=&S[++ncnt];
p->sz=1;
p->key=p->m=key;
p->lazy=p->rev=0;
p->ch[0]=p->ch[1]=p->f=null;
return p;
}
void pushdown(node *u)
{
if(u==null)return ;
if(u->lazy)
{
if(u->ch[0]!=null)
{
u->ch[0]->m+=u->lazy;
u->ch[0]->key+=u->lazy;
u->ch[0]->lazy+=u->lazy;
}
if(u->ch[1]!=null)
{
u->ch[1]->m+=u->lazy;
u->ch[1]->key+=u->lazy;
u->ch[1]->lazy+=u->lazy;
}
u->lazy=0;
}
if(u->rev)
{
swap(u->ch[0],u->ch[1]);
if(u->ch[0]!=null)u->ch[0]->rev^=1;
if(u->ch[1]!=null)u->ch[1]->rev^=1;
u->rev^=1;
}
}
void rotate(node *u)
{
node *f=u->f;
if(f==null)return ;
node *ff=f->f;
pushdown(u);
pushdown(f);
int d=u==f->ch[1];
int dd=(ff!=null)?(f==ff->ch[1]):0;

if(u->ch[d^1]!=null)u->ch[d^1]->f=f;
f->ch[d]=u->ch[d^1];

u->ch[d^1]=f;
f->f=u;

if(ff!=null)ff->ch[dd]=u;
u->f=ff;

f->rs();
u->rs();
}
void splay(node *u,node *p)
{
pushdown(u);
while(u->f!=p)
{
node *f=u->f;
node *ff=f->f;
if(ff==p)
{
rotate(u);
break;
}
int d=u==f->ch[1];
int dd=f==ff->ch[1];
if(d==dd)rotate(f);
else rotate(u);
rotate(u);
}
if(p==null)root=u;
u->rs();
}
void insert(node *&u,node *&fa,int key)
{
if(u==null)
{
u=newnode(key);
u->f=fa;
splay(u,null);
return ;
}
insert(u->ch[1],u,key);
u->rs();
}
char ss[20];
void find(int k,node *p)//找到排名为k的并旋到p下
{
node *u=root;
while(1)
{
pushdown(u);
if(u->ch[0]->sz+1==k)break;
if(u->ch[0]->sz>=k)u=u->ch[0];
else
{
k-=u->ch[0]->sz+1;
u=u->ch[1];
}
}
splay(u,p);
}
void Add(int l,int r,int x)//本来是要把l-1旋到根,r+1旋到
//根下,加了一个0，就是把l旋到根，r+2旋到根下
{
find(l,null);
find(r+2,root);
node *u=root->ch[1]->ch[0];
u->lazy+=x;
u->key+=x;
u->m+=x;
root->ch[1]->rs();
root->rs();
}
void REVERSE(int l,int r)//本来是操作l-1，r+1选到根
{
find(l,null);
find(r+2,root);
node *u=root->ch[1]->ch[0];
u->rev^=1;
}
void REVOLVE(int l,int r,int x)
//对于[l,r]这段区间向右移t位,相当于把最后t位放到前面
{
int t=(x%(r-l+1)+(r-l+1))%(r-l+1);
//分成两段[l,r-t] [r-t+1,r]
REVERSE(l,r-t);
REVERSE(r-t+1,r);
REVERSE(l,r);
}
void INSERT(int l,int x)
{
find(l+1,null);
find(l+2,root);
root->ch[1]->ch[0]=newnode(x);
root->ch[1]->ch[0]->f=root->ch[1];
root->ch[1]->rs();
root->rs();
splay(root->ch[1]->ch[0],null);
}
void DEL(int x)
{
find(x,null);
find(x+2,root);
root->ch[1]->ch[0]=null;
root->ch[1]->rs();
root->rs();
}
void MIN(int l,int r)
{
find(l,null);
find(r+2,root);
printf("%d\n",root->ch[1]->ch[0]->m);
splay(root->ch[1]->ch[0],null);
}
int main()
{
freopen("memo.in","r",stdin);
freopen("memo.out","w",stdout);
clear();
scanf("%d",&n);
insert(root,null,0);
for(int i=1;i<=n;i++)
{
int x;
scanf("%d",&x);
insert(root,null,x);
}
insert(root,null,1000001);
int l,r,x;
scanf("%d",&m);
for(int i=1;i<=m;i++)
{
scanf("%s",ss);
if(ss[0]=='A')
{
scanf("%d%d%d",&l,&r,&x);
Add(l,r,x);
}
else if(ss[0]=='R'&&ss[3]=='E')
{
scanf("%d%d",&l,&r);
REVERSE(l,r);
}
else if(ss[0]=='R'&&ss[3]=='O')
{
scanf("%d%d%d",&l,&r,&x);
REVOLVE(l,r,x);
}
else if(ss[0]=='I')
{
scanf("%d%d",&l,&x);
INSERT(l,x);
}
else if(ss[0]=='D')
{
scanf("%d",&x);
DEL(x);
}
else
{
scanf("%d%d",&l,&r);
MIN(l,r);
}
}
return 0;
}

　　　　　　　　　
继续回顾ｓｐｌａｙ