Treap和名次树

Treap名字的来源:Tree+Heap,正如名字一样,就是一颗简单的BST,一坨堆的合体。BST的不平衡的根本原因在于基于左<=根<=右的模式吃单调序列时候会无脑成长链,而Treap则添加一个优先级属性,值的大小随机生成,用最大堆的方式维护。之所以使用堆,是因为堆是一颗 完全二叉树,而BST梦寐以求的就是完全二叉结构,二者一结合,就产生了一种新的Balanced BST。Treap依赖于随机数,随机生成的优先级属性,通过简单的左右旋可以将长链旋转成近似完全二叉树结构,注意只是近似,平均情况下的树高是(log 1.46n),但是完全二叉是(log 2n),可以说还是有一点点差距的,不过基本接近红黑树的平衡状况。鉴于比红黑树好拍,而且可塑性很强(如果你是用STL红黑树),在不是很追求鲁棒性的前提下,Treap算是神器了。

常规的BST用不着Treap,Treap的一大作用是求第K大数,具体方法是每个结点维护一个附加信息s,s为所有子结点和自身结点的数量,形成一颗 Rank Tree(名次树),如果你是手拍红黑树,可以自己实现,用不着Treap。但是如果使用STL,STL高度封装特性使得我们无法定制自己的树,这点着实 蛋疼。记住Treap的优势:简化的可定制的红黑树!

先来介绍一下Treap的结点结构。

struct node
{
    node *ch[2];
    int v,r,s;    //v-value,r-random值,s-附加结点信息
    int cmp(int x)
    {
        if(x==v) return -1;
        return x<v?0:1;  //0-left,1-right
    }
    void maintain()   //维护附加信息s
    {
        s=1;
        if(ch[0]!=NULL) s+=ch[0]->s;
        if(ch[1]!=NULL) s+=ch[1]->s;
    }
}

Treap的结点结构

Treap的主操作由以下几部分构成:rotate、insert,remove。

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

rotate操作

void insert(node* &o,int x)
 {
        if(o==NULL)
            {o=new node;o->ch[0]=o->ch[1]=NULL;o->v=x;o->r=rand();o->s=1;}
        else
        {
            int d=x<o->v?0:1; //不使用cmp的原因:可能有重复元素
            insert(o->ch[d],x);
            if(o->ch[d]->r > o->r) rotate(o,d^1);
        }
        o->maintain();
    }

insert操作

void remove(node* &o,int x)
    {
        int d=o->cmp(x);
        if(d==-1)
        {
            if(o->ch[0]!=NULL&&o->ch[1]!=NULL)
            {
                int d2=o->ch[0]->r>o->ch[1]->r?1:0;
                rotate(o,d2);
                remove(o->ch[d2],x);
            }
            else {if(o->ch[0]==NULL) o=o->ch[1];else o=o->ch[0];}
        }
        else remove(o->ch[d],x);
        if(o!=NULL) o->maintain();
    }

remove操作

remove的操作比较繁点,分为三种情况:

1.左右子树都存在,得让左右结点较大的r转到根,然后移出原来的根。

2.左右子树存其一,根直接改成左/右即可。

3.左右子树不存在,直接NULL即可。

然后就是RankTree的操作:kth

int kth(node *&o,int k)
{
    if(o == NULL || k<=0 || k>o->s) return 0;
    int s = (o->ch[1] == NULL ? 0 : o->ch[1]->s);
    if(k == s + 1) return o->v;
    else if(k<=s) return kth(o->ch[1],k);
    else return kth(o->ch[0],k-s-1);
}

kth操作

@练习题

LA5031,查询指定点连通的第K大数。首先得明白连通≠邻接,所以查询某个点的连通点,得从该点的root进行。本题中虽然说是图,但是必须清 楚,图可以由多棵Tree合成。方法是先保持所有结点独立,各自为一颗Tree,然后对于有边的u、v,进行两颗Tree的合并操作。由于合并的时候要批 量修改父节点,这里借助于并查集完成操作。最麻烦的是删除指定一条边,如果正向处理,代码要写好多行。这里借助逆向操作,变删除为添加,就好办多了。注 意,一旦逆向后,原本修改结点的操作也要反过来。cmd里保存的是现有w的之前的w,然后覆盖w,逆向处理的时候修改的之前备份的值,而不是应该修改的 值。

主要操作为addedge,merge,change,query。

merge(src,dest): 土法子,就是把src所有点取出来insert。递归src左右子树,然后将src根的值insert到dest里面,最后src赋值NULL

addedge(u,v) :先确认合并的u、v是否在同一集合,如果不在,将结点少的点merge到结点多的点里面(优化)。

change(x,v): 先确定目标点的root,remove掉值为x的点(??对LRJ的代码产生疑惑,题目说是将指定id的点修改,万一有相同的x,那不就删了多点?) 然后insert值为v的点,修改w保存的值。

query: 每次通过并查集定位指定点的root,然后做kth,累加统计。

时间: 2024-10-11 12:47:57

Treap和名次树的相关文章

Treap 实现名次树

在主流STL版本中,set,map,都是BST实现的,具体来说是一种称为红黑树的动态平衡BST: 但是在竞赛中并不常用,因为红黑树过于复杂,他的插入 5 种,删除 6 中,代码量极大(如果你要改板子的话): 相比之下有一种Treap的动态平衡BST,却也可以做到插入,删除,查找的期望时间复杂度O(logn): 结点定义: struct Node { Node *ch[2]; int r; //优先级 int v; //值 int s; //结点总数 Node(int v):v(v) { ch[0

Treap实现名次树

Treap(树堆)的大部分功能STL的set都可以实现,但因为set的过度封装使得某些特定的功能不能实现,比如求第k大的值. Code: 1 #include<bits/stdc++.h> 2 using namespace std; 3 const int maxn = 1000 + 10; 4 5 struct node { 6 node *ch[2]; 7 int r; 8 int v; 9 int s; 10 node (int v):v(v) {ch[0] = ch[1] = NUL

poj 1442 Treap实现名次树

Treap的入门题目,每个结点多维护一个size表示以它为根的子树的结点数,然后查kth的时候一层一层向下即可. 1 #include <iostream> 2 #include <cstring> 3 #include <cstdlib> 4 #include <cstdio> 5 #include <ctime> 6 using namespace std; 7 8 struct Node 9 { 10 Node * ch[2]; 11 in

uvalive 5031 Graph and Queries 名次树+Treap

题意:给你个点m条边的无向图,每个节点都有一个整数权值.你的任务是执行一系列操作.操作分为3种... 思路:本题一点要逆向来做,正向每次如果删边,复杂度太高.逆向到一定顺序的时候添加一条边更容易.详见算法指南P235. 1 #include<cstdlib> 2 3 struct Node 4 { 5 Node *ch[2]; // 左右子树 6 int r; // 随机优先级 7 int v; // 值 8 int s; // 结点总数 9 Node(int v):v(v) 10 { 11

LA 5031 Graph and Queries —— Treap名次树

离线做法,逆序执行操作,那么原本的删除边的操作变为加入边的操作,用名次树维护每一个连通分量的名次,加边操作即是连通分量合并操作,每次将结点数小的子树向结点数大的子树合并,那么单次合并复杂度O(n1logn2),由于合并之后原本结点数少的子树结点数至少翻倍,所以每个结点最多被插入 logn 次,故总时间复杂度为 O(n log2n)  . 注意细节处理,代码如下: 1 #include <cstdio> 2 #include <cstdlib> 3 #include <cstr

UVa 1479 (Treap 名次树) Graph and Queries

这题写起来真累.. 名次树就是多了一个附加信息记录以该节点为根的树的总结点的个数,由于BST的性质再根据这个附加信息,我们可以很容易找到这棵树中第k大的值是多少. 所以在这道题中用一棵名次树来维护一个连通分量. 由于图中添边比较方便,用并查集来表示连通分量就好了,但是删边不太容易实现. 所以,先把所有的边删去,然后逆序执行命令.当然,C命令也要发生一些变化,比如说顺序的情况是从a变成b,那么逆序执行的话应该就是从b变成a. 最后两棵树的合并就是启发式合并,把节点数少的数并到节点数多的数里去. 1

bzoj1503 [NOI2004]郁闷的出纳员(名次树+懒惰标记)

1503: [NOI2004]郁闷的出纳员 Time Limit: 5 Sec  Memory Limit: 64 MBSubmit: 8705  Solved: 3027[Submit][Status][Discuss] Description OIER 公司是一家大型专业化软件公司,有着数以万计的员工.作为一名出纳员,我的任务之一便是统计每位员工的工资.这本来是一份不错的工作,但是令人郁闷的是, 我们的老板反复无常,经常调整员工的工资.如果他心情好,就可能把每位员工的工资加上一个相同的量.反

斜堆,非旋转treap,替罪羊树

一.斜堆 斜堆是一种可以合并的堆 节点信息: struct Node { int v; Node *ch[2]; }; 主要利用merge函数 Node *merge(Node *x, Node *y) { if(!x) return y; if(!y) return x; if(x->v < y->v) swap(x, y); x->ch[1] = merge(x->ch[1], y); return swap(x->ch[0], x->ch[1]), x; }

[COGS 2421] [HZOI 2016] 简单的Treap 笛卡尔树

笛卡尔树就是你给两维限制,一维堆R,一维二叉搜索树K,平地拔起一棵Treap,最广范的应用:用LCA求区间最值,建Treap,还有个什么范围top k我表示并不会查都查不到.它最妙最高的地方在于用栈来建树:我们可以先排序K然后一个个插入,那么我们都是最右端,横容易被卡,那么我们不从上到下,我们从下到上,用栈维护,那就把时间复杂度从O(n^2)降到O(n),具体过程见下图从图一到图二就是这么一个过程,我们在把K为13的点插入时要找到一个合适的位置,上比他大,下比他小(假设大根堆) 下面见代码 #i