伸展树(Splay Tree)

最新推荐文章于 2024-06-07 22:49:44 发布
最新推荐文章于 2024-06-07 22:49:44 发布
阅读量170 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/bennettz/p/8387220.html
版权

伸展树是一种自平衡二叉查找树，它将每次操作的节点都旋转到根节点，伸展树操作的均摊时间复杂度为logn

基本操作

存储

struct Splay{
    int key,size,num;//如果没有重复元素可不要num，如果无需维护元素排名可不要size 
    Splay *son[2],*fa;
    Splay(){
        memset(this,0,sizeof(Splay));
    }
    Splay(int x){
        key=x,num=size=1,fa=son[0]=son[1]=0;
    }
}*root;

伸展操作

　　伸展树的最基本的操作当然就是伸展了,这也是它自平衡的基础
　　splay(x,S)表示在保持伸展树有序性的前提下，通过一系列旋转将伸展树S中的元素x调整至树的根部。

　　旋转操作就不说了

　　

　　伸展操作大致分为3种情况(左右对称的算一种)

    1. x的父亲节点就是根节点：
      这时我们只需要单次旋转(x如果是左子节点就右旋,是右子节点就左旋)将x旋转到根即可
    2. x的父亲节点和x同为左节点(右节点)，如下图中x为4的情况：

      这时我们先将父节点旋转到爷爷节点

      然后再将x旋转到父节点

      这样x就向上移了两层,然后再进行判断并继续上移直到x为根节点

    3. x为右子节点但x父亲为左子节点或x为左子节点但x父亲为右子节点，如下图x为5的情况：

      这时，可以先将x旋转到父节点

      然后将x旋转到之前的爷爷节点

      这样x也向上移了两层,然后再进行判断并继续上移直到x为根节点

　　下面是旋转操作和伸展操作的代码(代码中将伸展操作中2，3情况的旋转分开了，也可以将旋转合并成一次操作)

#define size(x) (x?x->size:0)
#define is_r(x) (x->fa?x->fa->son[1]==x:0)
void rotate(Splay *&x,int d){//将x子树旋转,d=0表示左旋,d=1表示右旋 
    Splay *p=x->son[!d];
    x->son[!d]=p->son[d];//更新指针指向关系 
    if(p->son[d])p->son[d]->fa=x;
    p->son[d]=x,p->fa=x->fa,x->fa=p;
    p->size=x->size,x->size=size(x->son[0])+size(x->son[1])+x->num;//更新size值 
    x=p;
}
void up(Splay *x){//将x旋转到它的爷爷节点 
    bool d=is_r(x);
    Splay *&a=x->fa->fa->fa?x->fa->fa->fa->son[is_r(x->fa->fa)]:root;//a为指向爷爷节点的指针 
    if(is_r(x->fa)!=d){ 
        rotate(a->son[!d],!d),rotate(a,d);
    }
    else rotate(a,!d),rotate(a,!d);
}
void splay(Splay *x,Splay *&root){//伸展操作,将x节点旋转到root节点 
    while(x->fa!=root&&x!=root)up(x);
    if(x->fa==root)rotate(root,!is_r(x));
}

插入操作

　　 插入操作和二叉查找树的相同，只是插入过后执行伸展操作将节点旋转到根节点

void insert(Splay *&x,Splay *fa,int key){//插入key 
    if(!x){//插入到此 
        x=new Splay(key),x->fa=fa,splay(x,root);
        return;
    }
    x->size++;
    if(x->key==key){x->num++,splay(x,root);return;}//树中已经有key了
    int d=x->key<key;
    insert(x->son[d],x,key);
}

合并两棵splay子树

可合并前提:一棵子树的所有元素都大于另一棵子树的所有元素

　　首先将较小的那棵子树的最大的元素旋转到树根,这时它一定没有右子节点,将另一棵子树接上去即可

Splay* Max(Splay *x){//返回指向x中最大的节点的指针 
    while(x->son[1])x=x->son[1];
    return x;
}
Splay* Min(Splay *x){//返回指向x中最小的节点的指针 
    while(x->son[0])x=x->son[0];
    return x;
}
void Merge(Splay *&x,Splay *&y){//合并x，y子树(x中所有元素>y中所有元素)
    Splay *a=Max(x);//找到x中最大的节点 
    splay(a,x);//将x中最大的节点旋转到根 
    a->son[1]=y,y->fa=a;//将y接到x的右子节点 
}

删除操作

　　将要删除的节点旋转到树根，然后合并它的两棵子树即可

Splay* Find(Splay *x,int key){//返回指向权值为key的节点的指针 
    if(!x)return 0;
    if(x->key==key)return x;
    return Find(x->son[key>x->key],key);
}
void del(Splay *&x,int key){//删除 
    Splay *a=Find(x,key);//找到key 
    if(!a)return;//没找到就直接返回 
    splay(a,x);//将a旋转到根 
    if(a->num>1){a->num--,a->size--;return;}//插入不止一次，减一次即可 
    if(!a->son[0]){//左子节点为空,就直接用右子树替换原树 
        if(!a->son[1])root=NULL,delete a;
        else root=a->son[1],a->son[1]->fa=0,delete a;return;
    }
    if(!a->son[1]){//右子节点为空一样 
        root=a->son[0],a->son[0]->fa=0,delete a;return;
    }
    x=a->son[0],a->son[0]->fa=0;//合并两个子树 
    Merge(x,a->son[1]),delete a;
}

其他操作

void mid_traversal(Splay *x){//中序遍历
    if(x->son[0])mid_traversal(x->son[0]);
    printf("%d ",x->key);
    if(x->son[1])mid_traversal(x->son[1]);
}
int query_id(Splay *x,int key){//求数列中比key小的有几个 
    if(!x)return 0;
    if(x->key>key)return query_id(x->son[0],key);
    if(x->key==key)return size(x->son[0]);
    return query_id(x->son[1],key)+size(x->son[0])+x->num;
}
int query_k(Splay *x,int k){//求排第k的数 
    if(!x)return 0;
    if(size(x->son[0])>=k)return query_k(x->son[0],k);
    if(size(x->son[0])+x->num>=k)return x->key;
    return query_k(x->son[1],k-size(x->son[0])-x->num);
}
int ans;
void pre(Splay *x,int num){//求num的前驱(即小于num的最大的数)，并存在ans里 
    if(!x)return;
    if(x->key<num)ans=x->key,pre(x->son[1],num);
    else pre(x->son[0],num);
}
void suc(Splay *x,int num){//求后继 
    if(!x)return;
    if(x->key>num)ans=x->key,suc(x->son[0],num);
    else suc(x->son[1],num);
}

例题P3369 【模板】普通平衡树（Treap/SBT）

#include<cstdio>
#include<cstring>
using namespace std;
#define size(x) (x?x->size:0)
#define is_r(x) (x->fa?x->fa->son[1]==x:0)
struct Splay{
    int key,size,num;//如果没有重复元素可不要num，如果无需维护元素排名可不要size 
    Splay *son[2],*fa;
    Splay(){
        memset(this,0,sizeof(Splay));
    }
    Splay(int x){
        key=x,num=size=1,fa=son[0]=son[1]=0;
    }
}*root;
void mid_traversal(Splay *x){//中序遍历
    if(x->son[0])mid_traversal(x->son[0]);
    printf("%d ",x->key);
    if(x->son[1])mid_traversal(x->son[1]);
}
void rotate(Splay *&x,int d){//将x子树旋转,d=0表示左旋,d=1表示右旋 
    Splay *p=x->son[!d];
    x->son[!d]=p->son[d];//更新指针指向关系 
    if(p->son[d])p->son[d]->fa=x;
    p->son[d]=x,p->fa=x->fa,x->fa=p;
    p->size=x->size,x->size=size(x->son[0])+size(x->son[1])+x->num;//更新size值 
    x=p;
}
void up(Splay *x){//将x旋转到它的爷爷节点 
    bool d=is_r(x);
    Splay *&a=x->fa->fa->fa?x->fa->fa->fa->son[is_r(x->fa->fa)]:root;//a为指向爷爷节点的指针 
    if(is_r(x->fa)!=d){ 
        rotate(a->son[!d],!d),rotate(a,d);
    }
    else rotate(a,!d),rotate(a,!d);
}
void splay(Splay *x,Splay *&root){//伸展操作,将x节点旋转到root节点 
    while(x->fa!=root&&x!=root)up(x);
    if(x->fa==root)rotate(root,!is_r(x));
}
void insert(Splay *&x,Splay *fa,int key){//插入key 
    if(!x){//插入到此 
        x=new Splay(key),x->fa=fa,splay(x,root);
        return;
    }
    x->size++;
    if(x->key==key){x->num++,splay(x,root);return;}//树中已经有key了
    int d=x->key<key;
    insert(x->son[d],x,key);
}
Splay* Max(Splay *x){//返回指向x中最大的节点的指针 
    while(x->son[1])x=x->son[1];
    return x;
}
Splay* Min(Splay *x){//返回指向x中最小的节点的指针 
    while(x->son[0])x=x->son[0];
    return x;
}
void Merge(Splay *&x,Splay *&y){//合并x，y子树(x中所有元素>y中所有元素)
    Splay *a=Max(x);//找到x中最大的节点 
    splay(a,x);//将x中最大的节点旋转到根 
    a->son[1]=y,y->fa=a;//将y接到x的右子节点 
}
Splay* Find(Splay *x,int key){//返回指向权值为key的节点的指针 
    if(!x)return 0;
    if(x->key==key)return x;
    return Find(x->son[key>x->key],key);
}
void del(Splay *&x,int key){//删除 
    Splay *a=Find(x,key);//找到key 
    if(!a)return;//没找到就直接返回 
    splay(a,x);//将a旋转到根 
    if(a->num>1){a->num--;return;}//插入不止一次，减一次即可 
    if(!a->son[0]){//左子节点为空,就直接用右子树替换原树 
        root=a->son[1],a->son[1]->fa=0,delete a;return;
    }
    if(!a->son[1]){//右子节点为空一样 
        root=a->son[0],a->son[0]->fa=0,delete a;return;
    }
    x=a->son[0],a->son[0]->fa=0;//合并两个子树 
    Merge(x,a->son[1]),delete a;
}
int query_id(Splay *x,int key){//求数列中比key小的有几个 
    if(!x)return 0;
    if(x->key>key)return query_id(x->son[0],key);
    if(x->key==key)return size(x->son[0]);
    return query_id(x->son[1],key)+size(x->son[0])+x->num;
}
int query_k(Splay *x,int k){//求排第k的数 
    if(!x)return 0;
    if(size(x->son[0])>=k)return query_k(x->son[0],k);
    if(size(x->son[0])+x->num>=k)return x->key;
    return query_k(x->son[1],k-size(x->son[0])-x->num);
}
int ans;
void pre(Splay *x,int num){//求num的前驱(即小于num的最大的数)，并存在ans里 
    if(!x)return;
    if(x->key<num)ans=x->key,pre(x->son[1],num);
    else pre(x->son[0],num);
}
void suc(Splay *x,int num){//求后继 
    if(!x)return;
    if(x->key>num)ans=x->key,suc(x->son[0],num);
    else suc(x->son[1],num);
}
int main(){
    int n,x,y;scanf("%d",&n);
    while(n--){
        scanf("%d%d",&x,&y);
        switch(x){
            case 1:
                insert(root,0,y);
                break;
            case 2:
                del(root,y);
                break;
            case 3:
                printf("%d\n",query_id(root,y)+1);
                break;
            case 4:
                printf("%d\n",query_k(root,y));
                break;
            case 5:
                pre(root,y);printf("%d\n",ans);
                break;
            default:
                suc(root,y);printf("%d\n",ans);
            
        }
    }
    return 0;
}

维护非有序序列的区间操作

实际上Splay Tree不只能维护有序序列，我们可以丢掉它二叉搜索树的性质，然后就可以维护非有序序列

用处：由于Splay Tree独特的伸展操作，使得它可以较快的实现对区间的操作

例题SPOJ Another Sequence Problem

存储

　　因为有区间操作，所以每个节点还要存标记

struct Splay{
    int key,size,maxl,maxr,maxt,sum;//maxl为左区间最大值,maxr为右区间最大值, maxt为区间最大值 
    bool rev,same;//翻转和赋值标记 
    Splay *son[2],*fa;
    Splay(){
        memset(this,0,sizeof(Splay));
    }
    Splay(int x,Splay *f){
        sum=maxl=maxr=maxt=key=x,size=1,rev=same=0,fa=f;
    }
}

建树

　　每个根节点保存子树区间的中点,然后让左右子树分别保存被中点分成的两个区间

void build(Splay *&x,Splay *fa,int l,int r){//建立一棵[l,r]的子树,x指向子树的根,根的父亲为fa 
    if(l>r)return;
    int mid=(l+r)>>1;
    x=new Splay(a[mid],fa),x->son[0]=x->son[1]=null;//根节点存区间中点 
    build(x->son[0],x,l,mid-1);
    build(x->son[1],x,mid+1,r);
    update(x);
}

更新和下放标记

int Max(int n,...){//求n个数的max 
    va_list arg_ptr;
    va_start(arg_ptr, n);
    int ans = -inf;
    for(int i=0; i < n; ++i){
        int temp = va_arg(arg_ptr,int);
        ans=max(ans,temp);
    }
    va_end(arg_ptr);
    return ans;
}
void push_down(Splay *x){//下放标记 
    if(x==null)return;
    if(x->rev){//区间翻转 
        x->rev=0,x->son[0]->rev^=1,x->son[1]->rev^=1;
        swap(x->son[0],x->son[1]),swap(x->maxl,x->maxr);
    }
    if(x->same){//区间赋值 
        x->same=0,x->son[0]->key=x->son[1]->key=x->key;
        x->son[0]->same=x->son[1]->same=1;
        x->sum=x->key*x->size;
        x->maxl=x->maxr=x->maxt=(x->key>0?x->sum:x->key);
    }
}
void update(Splay *x){//更新节点 
    if(x==null)return;
    push_down(x),push_down(x->son[0]),push_down(x->son[1]);//要用到子节点的maxl,maxr所以要下放子节点标记 
    x->size=x->son[0]->size+x->son[1]->size+1,//更新节点存储的值 
    x->sum=x->son[0]->sum+x->son[1]->sum+x->key,
    x->maxl=max(x->son[0]->maxl,x->son[0]->sum+x->key+max(0,x->son[1]->maxl)),
    x->maxr=max(x->son[1]->maxr,x->son[1]->sum+x->key+max(0,x->son[0]->maxr));
    x->maxt=Max(3,x->son[0]->maxt,x->son[1]->maxt,max(0,x->son[0]->maxr)+max(0,x->son[1]->maxl)+x->key);
}

旋转和伸展

　　和上面的Splay相同，但旋转之前要先下放标记

void rotate(Splay *&x,int d){//旋转 
    Splay *p=x->son[!d];
    push_down(x),push_down(p);//先下放标记 
    x->son[!d]=p->son[d];//更新指向关系 
    if(p->son[d]!=null)p->son[d]->fa=x;
    p->son[d]=x,p->fa=x->fa,x->fa=p;
    update(x),update(p);//更新节点 
    x=p;//x指向p指向的位置
}
void up(Splay *x){//将x旋转到它的爷爷节点 
    bool d=is_r(x);
    Splay *&a=x->fa->fa->fa?x->fa->fa->fa->son[is_r(x->fa->fa)]:root;//a为指向爷爷节点的指针 
    if(is_r(x->fa)!=d){//x和父亲位于它们父亲的异侧 
        rotate(a->son[!d],!d),rotate(a,d);
    }
    else rotate(a,!d),rotate(a,!d);//x和父亲位于它们父亲的同侧 
}
void splay(Splay *x,Splay *&root){//将x节点旋转到root节点 
    if(x==null)return;
    while(x->fa!=root&&x!=root){
        up(x);
    }
    if(x->fa==root)rotate(root,!is_r(x));
}

查找

　　查找分3种情况：

  1. 如果左子树大小$\ge$k,则去左子树中查找第k个节点
  2. 如果左子树大小+1=k,则返回当前节点
  3. 否则去右子树中查找第k-(x->son[0]->size+1)个节点
Splay *Find(Splay *x,int k){//返回x子树中的第k个数 
    if(x==null)return 0;
    update(x);
    if(x->son[0]->size>=k)return Find(x->son[0],k);
    if(x->son[0]->size+1==k)return x;
    return Find(x->son[1],k-x->son[0]->size-1);
}

删除

删除[l,r]区间:

  1. 将原树中的第l-1个数旋转到根
  2. 将原树中的第r+1个数旋转到根的右子节点
  3. 这时根的右子节点的左子树即为要删除的区间

因为l,r可能是总区间的端点,l-1,r+1会越界,所以我们在区间的两端建两个空节点
实际操作为第l个数旋转到根,将第r+2个数旋转到根的右子节点(整体右移一个节点),下面的操作相同

void remove(Splay *x){//删除x子树 
    if(x==null)return;
    remove(x->son[0]),remove(x->son[1]),delete x;
}
void del(int l,int r){//删除[l,r] 
    splay(Find(root,l),root);//将l-1旋转到root 
    splay(Find(root,r+2),root->son[1]);//将r+1旋转到root的右儿子
    remove(root->son[1]->son[0]),root->son[1]->son[0]=null,update(root->son[1]),update(root);//r+1的左儿子即为区间[l,r]
}

插入

在x后面插入y个数：

  1. 将原树中的第x个数旋转到根
  2. 将原树中的第x+1个数旋转到根的右子节点
  3. 建一棵Splay保存这y个数
  4. 将新建的树接到根的右子节点的左子节点上 
    void insert(int l,int s){//在l后面插入长为s的区间 
    for(int i=0;i<s;i++){
        scanf("%d",a+i);
    }
    splay(Find(root,l+1),root),splay(Find(root,l+2),root->son[1]);//将l旋转到root,将l+1旋转到root的右儿子,这时l+1没有左儿子 
    build(root->son[1]->son[0],root->son[1],0,s-1),update(root),update(root->son[1]);//建树，更新 
}

其他操作

基本所有的对区间的操作都有两个相同的步骤：

  1. 将原树中的第l-1个数旋转到根
  2. 将原树中的第r+1个数旋转到根的右子节点

这样根的右子节点的左子树即为[l,r]，直接操作即可

void modify(int l,int r,int s){//将[l,r]都赋值为s 
    splay(Find(root,l),root);//将l-1旋转到root 
    splay(Find(root,r+2),root->son[1]);//将r+1旋转到root的右儿子 
    Splay *x=root->son[1]->son[0];//r+1的左儿子即为区间[l,r],打标记更新 
    x->same=1,x->key=s,update(root->son[1]),update(root);splay(x,root);
}
void rev(int l,int r){//将[l,r]翻转 
    splay(Find(root,l),root);//将l-1旋转到root 
    splay(Find(root,r+2),root->son[1]);//将r+1旋转到root的右儿子
    root->son[1]->son[0]->rev=1;//r+1的左儿子即为区间[l,r],打标记更新
    update(root->son[1]),update(root);
}
int get_sum(int l,int r){//求[l,r]的和 
    splay(Find(root,l),root);
    splay(Find(root,r+2),root->son[1]);
    return root->son[1]->son[0]->sum; 
}
int max_sum(){//求最大的区间值 
    update(root); 
    return root->maxt;
}

完整代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdarg.h>
using namespace std;
#define inf 0x3fffffff
#define is_r(x) (x->fa?x->fa->son[1]==x:0)
struct Splay{
    int key,size,maxl,maxr,maxt,sum;//maxl为左区间最大值,maxr为右区间最大值, maxt为区间最大值 
    bool rev,same;//翻转和赋值标记 
    Splay *son[2],*fa;
    Splay(){
        memset(this,0,sizeof(Splay));
    }
    Splay(int x,Splay *f){
        sum=maxl=maxr=maxt=key=x,size=1,rev=same=0,fa=f;
    }
}*root,*null=new Splay;
int a[500005];
//下面的宏在<stdarg.h>提供的有 
//typedef char *  va_list;//指针 
//#define _ADDRESSOF(n)   ( &reinterpret_cast<const char &>(n) ) //取n的地址并转为char* 
//#define _INTSIZEOF(n)  ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) ) //将sizeof(n)向上取至sizeof(int)的整数倍,在我电脑上必须*2才行 
//#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) ) //求第一位的地址存在ap中 
//#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) //取出ap的值，并将ap指向下一个位置
//#define va_end(ap)      ( ap = (va_list)0 )  //置空ap 
int Max(int n,...){//求n个数的max 
    va_list arg_ptr;
    va_start(arg_ptr, n);
    int ans = -inf;
    for(int i=0; i < n; ++i){
        int temp = va_arg(arg_ptr,int);
        ans=max(ans,temp);
    }
    va_end(arg_ptr);
    return ans;
}
void push_down(Splay *x){//下放标记 
    if(x==null)return;
    if(x->rev){//区间翻转 
        x->rev=0,x->son[0]->rev^=1,x->son[1]->rev^=1;
        swap(x->son[0],x->son[1]),swap(x->maxl,x->maxr);
    }
    if(x->same){//区间赋值 
        x->same=0,x->son[0]->key=x->son[1]->key=x->key;
        x->son[0]->same=x->son[1]->same=1;
        x->sum=x->key*x->size;
        x->maxl=x->maxr=x->maxt=(x->key>0?x->sum:x->key);
    }
}
void update(Splay *x){//更新节点 
    if(x==null)return;
    push_down(x),push_down(x->son[0]),push_down(x->son[1]);//要用到子节点的maxl,maxr所以要下放子节点标记 
    x->size=x->son[0]->size+x->son[1]->size+1,//更新节点存储的值 
    x->sum=x->son[0]->sum+x->son[1]->sum+x->key,
    x->maxl=max(x->son[0]->maxl,x->son[0]->sum+x->key+max(0,x->son[1]->maxl)),
    x->maxr=max(x->son[1]->maxr,x->son[1]->sum+x->key+max(0,x->son[0]->maxr));
    x->maxt=Max(3,x->son[0]->maxt,x->son[1]->maxt,max(0,x->son[0]->maxr)+max(0,x->son[1]->maxl)+x->key);
}
void mid_traversal(Splay *x){//中序遍历
    push_down(x);
    if(x->son[0]!=null)mid_traversal(x->son[0]);
    printf("%d %d\n",x->key,x->size);
    if(x->son[1]!=null)mid_traversal(x->son[1]);
}
void rotate(Splay *&x,int d){//旋转 
    Splay *p=x->son[!d];
    push_down(x),push_down(p);//先下放标记 
    x->son[!d]=p->son[d];//更新指向关系 
    if(p->son[d]!=null)p->son[d]->fa=x;
    p->son[d]=x,p->fa=x->fa,x->fa=p;
    update(x),update(p);//更新节点 
    x=p;//x指向p指向的位置
}
void up(Splay *x){//将x旋转到它的爷爷节点 
    bool d=is_r(x);
    Splay *&a=x->fa->fa->fa?x->fa->fa->fa->son[is_r(x->fa->fa)]:root;//a为指向爷爷节点的指针 
    if(is_r(x->fa)!=d){//x和父亲位于它们父亲的异侧 
        rotate(a->son[!d],!d),rotate(a,d);
    }
    else rotate(a,!d),rotate(a,!d);//x和父亲位于它们父亲的同侧 
}
void splay(Splay *x,Splay *&root){//将x节点旋转到root节点 
    if(x==null)return;
    while(x->fa!=root&&x!=root){
        up(x);
    }
    if(x->fa==root)rotate(root,!is_r(x));
}
void build(Splay *&x,Splay *fa,int l,int r){//建立一棵[l,r]的子树,x指向子树的根,根的父亲为fa 
    if(l>r)return;
    int mid=(l+r)>>1;
    x=new Splay(a[mid],fa),x->son[0]=x->son[1]=null;//根节点存区间中点 
    build(x->son[0],x,l,mid-1);
    build(x->son[1],x,mid+1,r);
    update(x);
}
Splay *Find(Splay *x,int k){//返回x子树中的第k个数 
    if(x==null)return 0;
    update(x);
    if(x->son[0]->size>=k)return Find(x->son[0],k);
    if(x->son[0]->size+1==k)return x;
    return Find(x->son[1],k-x->son[0]->size-1);
}
void insert(int l,int s){//在l后面插入长为s的区间 
    for(int i=0;i<s;i++){
        scanf("%d",a+i);
    }
    splay(Find(root,l+1),root),splay(Find(root,l+2),root->son[1]);//将l旋转到root,将l+1旋转到root的右儿子,这时l+1没有左儿子 
    build(root->son[1]->son[0],root->son[1],0,s-1),update(root),update(root->son[1]);//建树，更新 
}
void remove(Splay *x){//删除x子树 
    if(x==null)return;
    remove(x->son[0]),remove(x->son[1]),delete x;
}
void del(int l,int r){//删除[l,r] 
    splay(Find(root,l),root);//将l-1旋转到root 
    splay(Find(root,r+2),root->son[1]);//将r+1旋转到root的右儿子
    remove(root->son[1]->son[0]),root->son[1]->son[0]=null,update(root->son[1]),update(root);//r+1的左儿子即为区间[l,r]
}
void modify(int l,int r,int s){//将[l,r]都赋值为s 
    splay(Find(root,l),root);//将l-1旋转到root 
    splay(Find(root,r+2),root->son[1]);//将r+1旋转到root的右儿子 
    Splay *x=root->son[1]->son[0];//r+1的左儿子即为区间[l,r],打标记更新 
    x->same=1,x->key=s,update(root->son[1]),update(root);splay(x,root);
}
void rev(int l,int r){//将[l,r]翻转 
    splay(Find(root,l),root);//将l-1旋转到root 
    splay(Find(root,r+2),root->son[1]);//将r+1旋转到root的右儿子
    root->son[1]->son[0]->rev=1;//r+1的左儿子即为区间[l,r],打标记更新
    update(root->son[1]),update(root);
}
int get_sum(int l,int r){//求[l,r]的和 
    splay(Find(root,l),root);
    splay(Find(root,r+2),root->son[1]);
    return root->son[1]->son[0]->sum; 
}
int max_sum(){//求最大的区间值 
    update(root); 
    return root->maxt;
}
void work(){
    int n,m,l,r,k;scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",a+i);
    }
    a[0]=a[n+1]=-1000000000;
    build(root,0,0,n+1);
    char op[20];
    while(m--){
        scanf("%s",op);
        if(!strcmp(op,"MAKE-SAME")){
            scanf("%d%d%d",&l,&r,&k);
            modify(l,l+r-1,k);
        }
        else if(!strcmp(op,"INSERT")){
            scanf("%d%d",&l,&k);
            insert(l,k);
        }
        else if(!strcmp(op,"DELETE")){
            scanf("%d%d",&l,&r);
            del(l,l+r-1);
        }
        else if(!strcmp(op,"REVERSE")){
            scanf("%d%d",&l,&r);
            rev(l,l+r-1);
        }
        else if(!strcmp(op,"GET-SUM")){
            scanf("%d%d",&l,&r);
            printf("%d\n",get_sum(l,l+r-1));
        }
        else if(!strcmp(op,"MAX-SUM")){
            printf("%d\n",max_sum());
        }
    }
    remove(root);
}
int main(){
    null->maxt=null->maxl=null->maxr=-inf; 
    int t;scanf("%d",&t); 
    while(t--)work();
}

转载于:https://www.cnblogs.com/bennettz/p/8387220.html

weixin_30315435
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构伸展树splay.rar
07-16
伸展树（Splay Tree），也叫分裂树，是一种二叉排序树，它能在O(log n)内完成插入、查找和删除操作。它由丹尼尔·斯立特Daniel Sleator 和 罗伯特·恩卓·塔扬Robert Endre Tarjan 在1985年发明的。 [1] 在伸展树上...
splaytree.zip
04-23
展树（Splay Tree）是一种二叉搜索树，它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。
C++伸展树实现.zip
08-20
C++伸展树实现
伸展树(Splay tree)图解与实现(2020.10.22).pdf
10-26
伸展树(Splay tree)图解与实现(2020.10.22).pdf
NSSCTF WEB 题解（一）
2301_81105268的博客
06-04 1011
题目提示：F12下发环境，打开网址，进入网页后点击F12查看源代码直接查找flag可以得到flag。
机器学习实验----支持向量机(SVM)实现二分类
m0_73087960的博客
06-07 693
两侧距离最近的数据点到超平面的距离最大。超平面被用来划分特征空间，以便实现对数据进行分类或回归。在多分类实验中，是n元空间中，超平面就是一个n-1维的空间。我们实现的是二分类，就得到的是一条直线。给定样本数据集，假设样本特征为X，样本标签为y。其中y 的取值只能有+1和-1。表示样本正类和负类。公式：其中w代表每个特征前的系数，也就是超平面的法向量拉格朗日乘数法的主要是将有等式约束条件优化问题转换为无约束条件,求解带约束条件下的极值。
【图论】Leetcode 130. 被围绕的区域【中等】
FLGB
06-06 473
被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会被填充为 ‘X’。任何不在边界上，或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
PTA 7-4 按层遍历二叉树
LgdCjp的博客
06-03 512
用先序和中序序列构造一棵二叉树（树中结点个数不超过10个），通过用队记录结点访问次序的方法实现对二叉树进行按层遍历，即按层数由小到大、同层由左到右输出按层遍历序列。
堆排序的实现
2301_81154519的博客
06-01 495
堆排序的实现
[力扣题解] 617. 合并二叉树
东皇太一在此的博客
06-07 163
递归法遍历，随便一种遍历方式都可以，以前序遍历为例；
list的简单模拟实现
Jk_Mr的博客
06-02 918
list是带头双向循环链表。是序列容器，允许在序列中的任何位置进行常数时间的插入和删除操作，并且可以在两个方向上进行迭代。list被实现为双向链表；双向链表可以将其包含的每个元素存储在不同且不相关的存储位置中。通过将每个元素与其前面的元素和后面的元素的链接关联起来，可以在内部保持排序。
动态规划（Dynamic-Programming）问题讲解
m0_69594200的博客
06-01 907
01背包、完全背包、不同路径、Fibonacci数列
初识操作系统
m0_73928695的博客
06-04 932
操作系统是一个管理软硬件的软件。它通过管理好硬件资源和软件资源，从而实现对计算机用户提供良好的运行环境。作为一个程序员，了解操作系统是非常有必要的。
链表题目练习----重排链表
最新发布
friendhan2005的博客
06-07 167
重排链表的详解
The minCompileSdk (34) specified in adependency‘s AAR metadata
Chongchong's Home
06-03 166
如果老项目改动大的话，不想进行升级，就删除build.gradle文件中。这样就可以解决问题了。
【LinkedList】集合
weixin_61898502的博客
06-06 508
List是接口,有两个常用实现类ArrayListLinkedListList有的特点,LinkedList,例如 也是允许,且可以且大部分方法与ArrayList相似,都是可以来操作集合数据的但是也特殊提了的方法,getFirst,getLast等方法基于实现。
【数据结构】图论入门
2301_79828182的博客
06-07 862
完全图：任意两个点都有一条边相连无向完全图：n个结点就有n * (n - 1) / 2 条边有向完全图：n个结点就有n * (n - 1) 条边稀疏图：有很少的边或者弧的图（通常 m 远小于nlog(n)）稠密图：有较多的边或者弧的图（通常 m 大于nlog(n)）连通图：在无（有）向图G = (V,{E})中，若对任意两个顶点v、u，都存在v到u的路径，则称G是连通图（强连通图）建立一个顶点表（记录各个顶点信息）和一个邻接矩阵（表示各个顶点之间的关系）
day51 动态规划 121. 买卖股票的最佳时机 122.买卖股票的最佳时机II
m0_68259754的博客
06-07 522
1.确定dp数组（dp table）以及下标的含义dp[i][0] 表示第i天持有股票所得最多现金 ，dp[i][1] 表示第i天不持有股票所得最多现金持有2.确定递推公式， 那么可以由两个状态推出来那么dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);， 也可以由两个状态推出来同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
帮我生成一段splay平衡树代码
05-28
class SplayTree { private: Node *root; void left_rotate(Node *x) { Node *y = x->right; x->right = y->left; if (y->left != nullptr) { y->left->p = x; } y->p = x->p; if (x->p == nullptr) { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值