[总结] fhq_Treap 学习笔记

转自

无旋版 $Treap$。

只需要两个操作即可达到 $splay$ 的所有功能

1、$split$

它的主要思想就是把一个 $Treap$ 分成两个。

$split$ 操作有两种类型，一种是按照权值分配，一种是按前 k 个分配。

第一种就是把所有小于 k 的权值的节点分到一棵树中，第二种是把前 k 个分到一个树里。

权值版：

 void split(int o,int k,int &x,int &y){ //这里的x，y分别是将以o为根的树切开后第一个新子树的根和第二个新子树的根
     if(!o) x=y=;
     else {
         if(val[o]<=k)
             x=o,split(ch[o][],k,ch[o][],y);
         else
             y=o,split(ch[o][],k,x,ch[o][]);
         pushup(o);
     }
 }

对于我们遍历到每一个点，假如它的权值小于k，那么它的所有左子树，都要分到左边的树里，然后遍历它的右儿子。假如大于k，把它的所有右子树分到右边的树里，遍历左儿子。

因为它的最多操作次数就是一直分到底，效率就是 $O(logn)$。

对于前k个版的，就是像找第k大的感觉。每次减掉sze

void split(int now,int k,int &x,int &y){
    if (!now) x=y=;
    else{
        if (k<=siz[ch[now][]])
            y=now,split(ch[now][],k,x,ch[now][]);
        else
            x=now,split(ch[now][],k-sze[ch[now][]]-,ch[now][],y);
        pushup(now);
    }
}

2、$merge$

这个就是把两个 $Treap$ 合成一个，保证第一个的权值小于第二个。

因为第一个 $Treap$ 的权值都比较小，我们比较一下它的 $prio$ (优先级)，假如第一个的 $prio$ 小，我们就可以直接保留它的所有左子树，接着把第一个 $Treap$ 变成它的右儿子。反之，我们可以保留第二棵的所有右子树，指针指向左儿子。

你可以把这个过程形象的理解为在第一个 $ Treap$ 的右子树上插入第二个树，也可以理解为在第二个树的左子树上插入第一棵树。因为第一棵树都满足小于第二个树，所以就变成了比较 $prio$ 来确定树的形态。

也就是说，我们其实是遍历了第一个$Treap$ 的根->最大节点，第二个$Treap$的根->最小节点，也就是 $O(logn)$

int merge(int x,int y){
    if(!x or !y) return x+y;
    if(prio[x]<prio[y]){
        ch[x][]=merge(ch[x][],y);
        pushup(x);
        return x;
    }
    else{
        ch[y][]=merge(x,ch[y][]);
        pushup(y);
        return y;
    }
}

下面我们就可以通过这两个基本的东西实现各种各样的操作了。

3、insert

插入一个权值为 $k$ 的点，把树按照 $k$ 的权值 $split$ 成两个，再 $merge$ 回去。

4、remove

删除权值为 $k$ 的点，把树按照 $k$ 分成两个$a,b$ 再把$a$ 按照 $k-1$ 分成$c,d$。把$d$ 的两个儿子 $merge$起来，再 $merge(merge(c,d),b)$

void remove(int k){
    int x,y,z;
    split(Root,k,x,y);
    split(x,k-,x,z);
    z=merge(ch[z][],ch[z][]);
    Root=merge(x,merge(z,y));
}

其它见代码

// 普通平衡树 fhq_Treap
// By YoungNeal
#include<cstdio>
#include<cstdlib>
#define N 100005
#define inf 0x3f3f3f3f
 
int Root;
int n,opt,x,tot;
int val[N],prio[N];
int sze[N],ch[N][];
 
void pushup(int o){
    sze[o]=sze[ch[o][]]+sze[ch[o][]]+;
}
 
void split(int o,int k,int &x,int &y){
    if(!o) x=y=;
    else {
        if(val[o]<=k)
            x=o,split(ch[o][],k,ch[o][],y);
        else
            y=o,split(ch[o][],k,x,ch[o][]);
        pushup(o);
    }
}
 
int merge(int x,int y){
    if(!x or !y) return x+y;
    if(prio[x]<prio[y]){
        ch[x][]=merge(ch[x][],y);
        pushup(x);
        return x;
    }
    else{
        ch[y][]=merge(x,ch[y][]);
        pushup(y);
        return y;
    }
}
 
int newnode(int v){
    sze[++tot]=;
    val[tot]=v;
    prio[tot]=rand();
    return tot;
}
 
void insert(int k){
    int x,y;
    split(Root,k,x,y);
    Root=merge(merge(x,newnode(k)),y);
}
 
void remove(int k){
    int x,y,z;
    split(Root,k,x,y);
    split(x,k-,x,z);
    z=merge(ch[z][],ch[z][]);
    Root=merge(x,merge(z,y));
}
 
void kthrank(int k){
    int x,y;
    split(Root,k-,x,y);
    printf("%d\n",sze[x]+);
    Root=merge(x,y);
}
 
int rank(int o,int k){
    if(sze[ch[o][]]==k-) return val[o];
    if(sze[ch[o][]]>=k) return rank(ch[o][],k);
    return rank(ch[o][],k-sze[ch[o][]]-);
}
 
void prev(int k){
    int x,y;
    split(Root,k-,x,y);
    printf("%d\n",rank(x,sze[x]));
    Root=merge(x,y);
}
 
void nxt(int k){
    int x,y;
    split(Root,k,x,y);
    printf("%d\n",rank(y,));
    Root=merge(x,y);
}
 
signed main(){
    scanf("%d",&n);
    while(n--){
        scanf("%d%d",&opt,&x);
        if(opt==) insert(x);
        if(opt==) remove(x);
        if(opt==) kthrank(x);
        if(opt==) printf("%d\n",rank(Root,x));
        if(opt==) prev(x);
        if(opt==) nxt(x);
    }
    return ;
}

5、区间操作

对于翻转区间 $[l,r]$，我们可以先把区间 $[1,l-1]$ $split$ 出来，再把 $[l,r]$ $split$ 出来就行了。注意 $lazy$ 标记及时清除。

// 文艺平衡树 fhp_Treap
// By YoungNeal
#include<ctime>
#include<cstdio>
#include<cstdlib>
#define N 100005
 
int Root;
int lazy[N];
int n,m,cnt;
int val[N],sze[N];
int ch[N][],prio[N];
 
void pushup(int o){
    sze[o]=sze[ch[o][]]+sze[ch[o][]]+;
}
 
void pushdown(int o){
    if(!lazy[o] or !o) return;
    ch[o][]^=ch[o][]^=ch[o][]^=ch[o][];
    lazy[ch[o][]]^=;
    lazy[ch[o][]]^=;
    lazy[o]=;
}
 
void split(int o,int k,int &x,int &y){
    if(!o) x=y=;
    else{
        pushdown(o);
        if(k>sze[ch[o][]]) x=o,split(ch[o][],k-sze[ch[o][]]-,ch[o][],y);
        else y=o,split(ch[o][],k,x,ch[o][]);
        pushup(o);
    }
}
 
int merge(int x,int y){
    if(!x or !y) return x+y;
    pushdown(x); pushdown(y);
    if(prio[x]<prio[y]){
        ch[x][]=merge(ch[x][],y);
        pushup(x);
        return x;
    }
    else{
        ch[y][]=merge(x,ch[y][]);
        pushup(y);
        return y;
    }
}
 
int newnode(int v){
    val[++cnt]=v;
    sze[cnt]=;
    prio[cnt]=rand();
    return cnt;
}
 
void res(int l,int r){
    int a,b,c,d;
    split(Root,r,a,b);
    split(a,l-,c,d);
    lazy[d]^=;
    Root=merge(merge(c,d),b);
}
 
void dfs(int now){
    if(!now) return;
    pushdown(now);
    dfs(ch[now][]);
    printf("%d ",val[now]);
    dfs(ch[now][]);
}
 
signed main(){
    srand(time());
    scanf("%d%d",&n,&m);
    for(int i=;i<=n;i++)
        Root=merge(Root,newnode(i));
    //printf("Root=%d\n",Root);
    for(int x,y,i=;i<=m;i++){
        scanf("%d%d",&x,&y);
        res(x,y);
        //printf("i=%d\n",i);
        //dfs(Root);
    }
    //printf("Root=%d\n",Root);
    dfs(Root);
    return ;
}