HDU 3487 Play with Chain

人生第一个splay题。

区间分裂，区间合并还有区间翻转都是比较裸的板子

一个区间分裂成三个区间还是写一个两两分裂的函数比较好写（

区间合并也是

感觉其他也没有什么要针对这个题说的

如果用动态内存的话建议用数组指针，不然会MLE（窝也不造是不是叫这个）

只要splay写好了就能过

以及代码如下

#include<bits\stdc++.h>
using namespace std;

#define l ch[0]
#define r ch[1]

struct node{
int val,siz;
int flp;
node *ch[2];
void maintain(){
siz=1;
if(ch[0]) siz+=ch[0]->siz;
if(ch[1]) siz+=ch[1]->siz;
}
};

const int maxn = 312345;
node nodes[maxn];
int tot;

int size(node *o){
if(o==NULL){
return 0;
}
return o->siz;
}

void zg(node* &o,int d){
node *k=o->ch[d];
o->ch[d]=k->ch[1^d];
k->ch[1^d]=o;
o=k;
o->ch[1^d]->maintain();
o->maintain();
}

node *newnode(int x){
node * ret = &nodes[tot++];
ret->flp=0;
ret->val = x;
ret->siz = 0;
ret->l=ret->r=NULL;
return ret;
}

void push(node *rot){
rot->flp=0;
swap(rot->l,rot->r);
if(rot->l)
rot->l->flp ^=1;
if(rot->r)
rot->r->flp ^=1;
}

int splay(node* &rot,int x){
if(rot->flp)
push(rot);
if(size(rot->l)+1==x)
return 2;
int d = size(rot->l)+1 > x? 0:1;
if(d) x-=size(rot->l)+1;
int k = splay(rot->ch[d],x);
if(k==2) return d;
if(k==d){
zg(rot,d);zg(rot,d);
}
else{
zg(rot->ch[d],k);zg(rot,d);
}
return 2;
}

void fnd(node* &root,int x){
if(!root)
return;
int k = splay(root,x);
if(k!=2)
zg(root,k);
}

void out(node *rot,int d,int k){
if(rot->r)
out(rot->r,d+1,-1);
for(int i = 0;i<d;i++)
printf("  ");
if(k==0){
printf("--");
}
else{
printf(" ");
if(k==-1)
printf("/");
else
printf("\\");
}
printf("%d(%d)\n",rot->val,rot->siz);
if(rot->l)
out(rot->l,d+1,1);
}

void print(node *rot){
puts("-------------");
if(!rot)
puts("NULL!");
else
out(rot,0,0);
puts("=============");
}

node *splite(node *&rot,int x){
if(x==0){
node *ret = rot;
rot=NULL;
return ret;
}
fnd(rot,x);
node *ret = rot->r;
rot->r=NULL;
rot->maintain();
return ret;
}

node *merg(node* L,node* R){
if(L){
fnd(L,L->siz);
L->r=R;
L->maintain();
return L;
}
if(R){
fnd(R,1);
R->l=L;
R->maintain();
return R;
}
return NULL;
}

void cut(int L,int R,int C,node* &root){
node *right=splite(root,R);
node *left=splite(root,L-1);
swap(left,root);
left=merg(left,right);
right=splite(left,C);
left=merg(left,root);
root=merg(left,right);
}

void flip(int L,int R,node* &root){
node *right=splite(root,R);
node *left=splite(root,L-1);
swap(left,root);
root->flp ^=1 ;
if(left)
root=merg(left,root);
if(right){
fnd(right,1);
right->l=root;
right->maintain();
root=right;
}

}

node *build(int n){
node *root = newnode(1);
root->maintain();
for(int i =2;i<=n;i++){
node *k = newnode(i);
k->l = root;
root = k;
root->maintain();
}
return root;
}

int ans[maxn];
int len;

void mid(node *root){
if(root->flp)
push(root);
if(root->l)
mid(root->l);
ans[len++]=root->val;
if(root->r)
mid(root->r);
}

int main(){
int n,m;
char arr[10];
while(~scanf("%d %d",&n,&m) && (n+1)||(m+1)){
tot=0;
node *root = build(n);
int L,R,C;
while(m--){
scanf("%s %d %d",arr,&L,&R);
if(arr[0]=='C'){
scanf("%d",&C);
cut(L,R,C,root);
//      print(root);
}
else{
flip(L,R,root);
//     print(root);
}
}
len=0;
mid(root);
for(int i = 0;i<n;i++)
printf(i<n-1?"%d ":"%d\n",ans[i]);
}
return 0;
}

===================================update====================

又写了一发，在右边添加了一个虚拟节点，优化了cut和flip的代码量

node *getseg(int L,int R,node* &root){ //goal is return->l and father is return
L--,R++;
if(L){
fnd(root,L);
fnd(root->r,R-L);
return root->r;
}
else{
fnd(root,R);
return root;
}
}

void flip(node* &root,int L,int R){
node * k = getseg(L,R,root);
k->l->flp ^= 1;
}

void cut(node* &root,int L,int R,int c){
node * fa = getseg(L,R,root);
node * k = fa->l;
fa->l=NULL; fa->maintain();
root->maintain();
if(c){
fnd(root,c);
fnd(root,c+1);
root->l->r=k;
root->l->maintain();
root->maintain();
}
else{
fnd(root,1);
root->l=k;
root->maintain();
}

}