splay2(区间修改+内存回收)

poj3580

要求写一种数据结构；

对一个序列进行

区间增减(add)； 区间翻转(reverse)；  区间移动(revolve)；

插入(insert)；   删除(delete)；          求区间最小值(min)；

据说各种方法都可以做，但是只学了splay；

对于(revolve)是指，将区间[x,y]旋转t次

{1,2,3,4,5}   revolve(2,4,2);    {1,2,3,4,5}->{1,4,2,3,5}->{1,3,2,4,5}

PS:小常数rotate & splay操作(zuo si)

void small_const_rotate(int x,int d){
  int y=T[x].fa;
  T[y].son[!d]=T[x].son[d];
  T[T[x].son[d]].fa=y;
  if(T[y].fa) T[T[y].fa].son[T[T[y].fa].son[1]==y]=x;
  T[x].fa=T[y].fa,T[x].son[d]=y;
  T[y].fa=x;
  up(y);
}

void small_const_splay(int x,int goal){//伸展操作，将x调整到goal下面
  lazy(x);
  while(T[x].fa!=goal){
    if(T[T[x].fa].fa==goal){
      lazy(T[x].fa),lazy(x);
      rotate(x,T[T[x].fa].son[0]==x);//这题有反转操作，需要先lazy,在判断左右孩子
    }
    else{
      lazy(T[T[x].fa].fa),lazy(T[x].fa),lazy(x);//这题有反转操作，需要先lazy,在判断左右孩子
      int y=T[x].fa , k=(T[T[y].fa].son[0]==y);
      if(T[y].son[k]==x)rotate(x,k^1),rotate(x,k);//两个方向不同，则先左旋再右旋
      else              rotate(y,k),rotate(x,k);  //两个方向相同，相同方向连续两次
    }
  }
  up(x);
  if(goal==0) root=x;
}

 模板如下：

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <cmath>
#include <queue>
#include <map>
#include <set>
using namespace std;
#define file(x) freopen(x".in","r",stdin),freopen(x".out","w",stdout)
#define Front T[T[root].son[1]].son[0]
#define ls T[x].son[0]
#define rs T[x].son[1]
const int MAXN=100000+10;
const int INF=(int)2e9;
int a[MAXN],n,m;
struct splay_tree{
  struct Node{
    int son[2],fa,key,size,add,rev,min;
    void init(){
      son[0]=son[1]=fa=key=size=add=rev=0;
      min=INF;
    }
  }T[MAXN];
  int root,tot,s[MAXN],top;//内存池、内存池容量

  void NewNode(int &x,int fa,int key){
    if(top)x=s[top--];
    else    x=++tot;
    ls=rs=0;
    T[x].fa=fa,T[x].size=1;
    T[x].add=T[x].rev=0;
    T[x].key=T[x].min=key;
  }

  void up_rev(int x){
    if(x==0)return;
    swap(ls,rs);
    T[x].rev^=1;
  }

  void up_add(int x,int val){
    if(x==0)return;
    T[x].add+=val, T[x].key+=val, T[x].min+=val;
  }

  void up(int x){
    T[x].size=T[ls].size+T[rs].size+1;
    T[x].min=T[x].key;
    if(ls)T[x].min=min(T[x].min,T[ls].min);
    if(rs)T[x].min=min(T[x].min,T[rs].min);
  }

  void lazy(int x){
    if(T[x].rev){
      up_rev(ls); up_rev(rs);
      T[x].rev=0;
    }
    if(T[x].add){
      up_add(ls,T[x].add); 
      up_add(rs,T[x].add);
      T[x].add=0;
    }
  }

  void build(int &x,int l,int r,int fa){
    if(l>r)return;
    int mid=(l+r)>>1;
    NewNode(x,fa,a[mid]);
    build(ls,l,mid-1,x);
    build(rs,mid+1,r,x);
    up(x);
  }

  void init(){
    root=tot=top=0;
    T[root].init();
    NewNode(root,0,INF);
    NewNode(T[root].son[1],root,INF);
    build(Front,1,n,T[root].son[1]);
    up(T[root].son[1]);
    up(root);
  }

  void rotate(int x,int k){
    int y=T[x].fa,z=T[y].fa;
    T[y].son[k^1]=T[x].son[k] ,T[T[x].son[k]].fa=y;
    T[x].son[k]=y ,T[y].fa=x;
    T[z].son[T[z].son[1]==y]=x ,T[x].fa=z;
    up(y);
  }

  void splay(int x,int goal){
    if(x==goal)return;
    while(T[x].fa!=goal){
      int y=T[x].fa,z=T[y].fa;
      lazy(z),lazy(y),lazy(x);
      int rx=T[y].son[0]==x ,ry=T[z].son[0]==y;
      if(z==goal)rotate(x,rx);
      else{
        if(rx==ry)rotate(y,ry);
        else      rotate(x,rx);
        rotate(x,ry);
      }
    }
    up(x);
    if(goal==0)root=x;
  }

  int kth(int x,int k){
    lazy(x);
    int s=T[ls].size+1;
    if(s==k)return x;
    if(s>k)return kth(ls,k);
    else   return kth(rs,k-s);
  }

  void erase(int x){
    if(x){
      s[++top]=x;
      erase(ls);
      erase(rs);
    }
  }

  void update_add(int l,int r,int val){
    splay(kth(root,l),0);
    splay(kth(root,r+2),root);
    up_add(Front,val);
    up(T[root].son[1]);
    up(root);
  }

  void update_reverse(int l,int r){
    splay(kth(root,l),0);
    splay(kth(root,r+2),root);
    up_rev(Front);
    up(T[root].son[1]);
    up(root);
  }

  void update_revolve(int l,int r,int t){
    int len=r-l+1; t=(t%len+len)%len;if(t==0) return;
    int k=r-t+1;
    splay(kth(root,k),0);
    splay(kth(root,r+2),root);
    int tmp=Front;
    Front=0;
    up(T[root].son[1]);
    up(root);
    splay(kth(root,l),0);
    splay(kth(root,l+1),root);
    Front=tmp;
    T[Front].fa=T[root].son[1];
    up(T[root].son[1]);
    up(root);
  }

  void update_insert(int x,int P){
    splay(kth(root,x+1),0);
    splay(kth(root,x+2),root);
    NewNode(Front,T[root].son[1],P);
    up(T[root].son[1]);
    up(root);
  }

  void update_delete(int x){
    splay(kth(root,x),0);
    splay(kth(root,x+2),root);
    erase(Front);
    T[Front].fa=0;
    Front=0;
    up(T[root].son[1]);
    up(root);
  }

  int query_min(int l,int r){
    splay(kth(root,l),0);
    splay(kth(root,r+2),root);
    return T[Front].min;
  }

  void work(){
    char str[10];int x,y,D,P,T;
    scanf("%d",&n);for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    init();
    for(scanf("%d",&m);m--;){
      scanf("%s%d",str,&x);
      if(strcmp(str,"DELETE")==0)update_delete(x);
      else if(strcmp(str,"INSERT")==0)scanf("%d",&P),update_insert(x,P);
      else if(strcmp(str,"ADD")==0)scanf("%d%d",&y,&D),update_add(x,y,D);
      else if(strcmp(str,"REVERSE")==0)scanf("%d",&y),update_reverse(x,y);
      else if(strcmp(str,"MIN")==0)scanf("%d",&y),printf("%d\n",query_min(x,y));
      else if(strcmp(str,"REVOLVE")==0)scanf("%d%d",&y,&T),update_revolve(x,y,T);
    }
  }
}poj3580;
int main(){poj3580.work();return 0;}