模板 - 数据结构 - Treap

还有人把Treap叫做树堆的，但是常用名还是叫做Treap的比较多。

不进行任何封装的，带求和操作的，一个节点存放多个元素的最普通的Treap。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define ls ch[id][0]
#define rs ch[id][1]

const int INF = 1e9;

const int MAXN = 1000000 + 5;
int ch[MAXN][2], dat[MAXN];

int val[MAXN];
int cnt[MAXN];
int siz[MAXN];
ll sum[MAXN];

int tot, root;

inline void Init() {
    tot = 0;
    root = 0;
}

inline int NewNode(int v, int num) {
    int id = ++tot;
    ls = rs = 0;
    dat[id] = rand();
    val[id] = v;
    cnt[id] = num;
    siz[id] = num;
    sum[id] = 1ll * num * v;
    return id;
}

inline void PushUp(int id) {
    siz[id] = siz[ls] + siz[rs] + cnt[id];
    sum[id] = sum[ls] + sum[rs] + 1ll * cnt[id] * val[id];
}

inline void Rotate(int &id, int d) {
    int temp = ch[id][d ^ 1];
    ch[id][d ^ 1] = ch[temp][d];
    ch[temp][d] = id;
    id = temp;
    PushUp(ch[id][d]);
    PushUp(id);
}

//插入num个v
inline void Insert(int &id, int v, int num) {
    if(!id)
        id = NewNode(v, num);
    else {
        if(v == val[id])
            cnt[id] += num;
        else {
            int d = val[id] > v ? 0 : 1;
            Insert(ch[id][d], v, num);
            if(dat[id] < dat[ch[id][d]])
                Rotate(id, d ^ 1);
        }
        PushUp(id);
    }
}

//删除至多num个v
void Remove(int &id, int v, int num) {
    if(!id)
        return;
    else {
        if(v == val[id]) {
            if(cnt[id] > num) {
                cnt[id] -= num;
                PushUp(id);
            } else if(ls || rs) {
                if(!rs || dat[ls] > dat[rs])
                    Rotate(id, 1), Remove(rs, v, num);
                else
                    Rotate(id, 0), Remove(ls, v, num);
                PushUp(id);
            } else
                id = 0;
        } else {
            val[id] > v ? Remove(ls, v, num) : Remove(rs, v, num);
            PushUp(id);
        }
    }
}

//查询v的排名，排名定义为<v的数的个数+1。
int GetRank(int id, int v) {
    int res = 1;
    while(id) {
        if(val[id] > v)
            id = ls;
        else if(val[id] == v) {
            res += siz[ls];
            break;
        } else {
            res += siz[ls] + cnt[id];
            id = rs;
        }
    }
    return res;
}

//查询排名为rk的数，rk必须是正整数，rk过大返回无穷
int GetValue(int id, int rk) {
    int res = INF;
    while(id) {
        if(siz[ls] >= rk)
            id = ls;
        else if(siz[ls] + cnt[id] >= rk) {
            res = val[id];
            break;
        } else {
            rk -= siz[ls] + cnt[id];
            id = rs;
        }
    }
    return res;
}

//查询v的前驱的值（<v的第一个节点的值），不存在前驱返回负无穷
int GetPrev(int id, int v) {
    int res = -INF;
    while(id) {
        if(val[id] < v)
            res = val[id], id = rs;
        else
            id = ls;
    }
    return res;
}

//查询v的后继的值（>v的第一个节点的值），不存在后继返回无穷
int GetNext(int id, int v) {
    int res = INF;
    while(id) {
        if(val[id] > v)
            res = val[id], id = ls;
        else
            id = rs;
    }
    return res;
}

//查询小于等于v的数的和
ll GetSumValue(int id, int v) {
    ll res = 0;
    while(id) {
        if(val[id] > v)
            id = ls;
        else if(val[id] == v) {
            res += sum[ls] + 1ll * cnt[id] * val[id];
            break;
        } else {
            res += sum[ls] + 1ll * cnt[id] * val[id];
            id = rs;
        }
    }
    return res;
}

//查询前rk个数的和，rk必须是正整数
ll GetSumRank(int id, int rk) {
    ll res = 0;
    while(id) {
        if(siz[ls] >= rk)
            id = ls;
        else if(siz[ls] + cnt[id] >= rk) {
            res += sum[ls] + 1ll * (rk - siz[ls]) * val[id];
            break;
        } else {
            res += sum[ls] + 1ll * cnt[id] * val[id];
            rk -= siz[ls] + cnt[id];
            id = rs;
        }
    }
    return res;
}

封装了val的，速度略微下降，因为是键值对所以求和类的函数变得没什么意义。

struct TreapNode {
    int val1, val2;
    TreapNode() {}
    TreapNode(int val1, int val2): val1(val1), val2(val2) {}

    bool operator<(const TreapNode& tn)const {
        return val1 < tn.val1;
    }
    bool operator<=(const TreapNode& tn)const {
        return val1 <= tn.val1;
    }
    bool operator==(const TreapNode& tn)const {
        return val1 == tn.val1;
    }
    bool operator>=(const TreapNode& tn)const {
        return val1 >= tn.val1;
    }
    bool operator>(const TreapNode& tn)const {
        return val1 > tn.val1;
    }
} TNINF(INF, INF);

/*#define TreapNode pii
TreapNode TNINF(INF, INF);*/

struct Treap {
#define ls ch[id][0]
#define rs ch[id][1]
    static const int MAXN = 200000;
    int ch[MAXN + 5][2], dat[MAXN + 5];

    TreapNode val[MAXN + 5];

    int cnt[MAXN + 5];
    int siz[MAXN + 5];

    int tot, root;

    void Init() {
        tot = 0;
        root = 0;
    }

    int NewNode(TreapNode v, int num) {
        int id = ++tot;
        ls = rs = 0;
        dat[id] = rand();
        val[id] = v;
        cnt[id] = num;
        siz[id] = num;
        return id;
    }

    void PushUp(int id) {
        siz[id] = siz[ls] + siz[rs] + cnt[id];
    }

    void Rotate(int &id, int d) {
        int temp = ch[id][d ^ 1];
        ch[id][d ^ 1] = ch[temp][d];
        ch[temp][d] = id;
        id = temp;
        PushUp(ch[id][d]);
        PushUp(id);
    }

    //插入num个v
    void _Insert(int &id, TreapNode v, int num) {
        if(!id)
            id = NewNode(v, num);
        else {
            if(v == val[id])
                cnt[id] += num;
            else {
                int d = val[id] > v ? 0 : 1;
                _Insert(ch[id][d], v, num);
                if(dat[id] < dat[ch[id][d]])
                    Rotate(id, d ^ 1);
            }
            PushUp(id);
        }
    }

    //删除至多num个v
    void _Remove(int &id, TreapNode v, int num) {
        if(!id)
            return;
        else {
            if(v == val[id]) {
                if(cnt[id] > num) {
                    cnt[id] -= num;
                    PushUp(id);
                } else if(ls || rs) {
                    if(!rs || dat[ls] > dat[rs])
                        Rotate(id, 1), _Remove(rs, v, num);
                    else
                        Rotate(id, 0), _Remove(ls, v, num);
                    PushUp(id);
                } else
                    id = 0;
            } else {
                val[id] > v ? _Remove(ls, v, num) : _Remove(rs, v, num);
                PushUp(id);
            }
        }
    }

    //查询v的排名，排名定义为<v的数的个数+1。
    int _GetRank(int id, TreapNode v) {
        int res = 1;
        while(id) {
            if(val[id] > v)
                id = ls;
            else if(val[id] == v) {
                res += siz[ls];
                break;
            } else {
                res += siz[ls] + cnt[id];
                id = rs;
            }
        }
        return res;
    }

    //查询排名为rk的数，rk必须是正整数，rk过大返回无穷
    TreapNode _GetValue(int id, int rk) {
        TreapNode res = TNINF;
        while(id) {
            if(siz[ls] >= rk)
                id = ls;
            else if(siz[ls] + cnt[id] >= rk) {
                res = val[id];
                break;
            } else {
                rk -= siz[ls] + cnt[id];
                id = rs;
            }
        }
        return res;
    }

    int Size() {
        return siz[root];
    }
    void Insert(TreapNode v, int num = 1) {
        _Insert(root, v, num);
    }
    void Remove(TreapNode v, int num = INF) {
        _Remove(root, v, num);
    }
    int GetRank(TreapNode v) {
        return _GetRank(root, v);
    }
    TreapNode GetValue(int rk) {
        return _GetValue(root, rk);
    }
#undef ls
#undef rs
}

原文地址：https://www.cnblogs.com/KisekiPurin2019/p/12083038.html

时间： 2024-08-01 16:39:14

模板 - 数据结构 - Treap的相关文章

模板 - 数据结构 - 无旋Treap / FHQ Treap

普通平衡树: #include<bits/stdc++.h> using namespace std; typedef long long ll; #define ls(p) ch[p][0] #define rs(p) ch[p][1] const int MAXN = 100000 + 5; int val[MAXN], ch[MAXN][2], rnd[MAXN], siz[MAXN], tot, root; void Init() { tot = root = 0; } void Pu

算法模板——平衡树Treap 2

实现功能:同平衡树Treap 1(BZOJ3224 / tyvj1728) 这次的模板有了不少的改进,显然更加美观了,几乎每个部分都有了不少简化,尤其是删除部分,这个参照了hzwer神犇的写法,在此鸣谢,然后,贴模板走人 1 var 2 i,j,k,l,m,n,head,tot:longint; 3 a,b,lef,rig,fix:array[0..100010] of longint; 4 function min(x,y:longint):longint; 5 begin 6 if x<y

算法模板——平衡树Treap

实现功能如下——1. 插入x数2. 删除x数(若有多个相同的数,因只删除一个)3. 查询x数的排名(若有多个相同的数,因输出最小的排名)4. 查询排名为x的数5. 求x的前驱(前驱定义为小于x,且最大的数)6. 求x的后继(后继定义为大于x,且最小的数) 本程序的实现原理为Treap平衡树详见BZOJ3224 1 var 2 i,j,k,l,m,n,head,ts:longint;f1:text; 3 a,b,fix,lef,rig:array[0..500000] of longint; 4

*模板--数据结构

非递归线段树(未测试) 1 const int maxn=1e5+10; 2 int a[maxn],n; //原数组,从1开始 3 struct SegTree{ 4 int N; 5 int sum[maxn<<2],add[maxn<<2]; 6 7 //建树 8 void build(){ 9 N=1;while(N<n+2) N<<=1; 10 for(int i=1;i<=n;i++) sum[i+N]=a[i]; //原数组下标+N=存储下标

模板 - 数据结构 - 线段树（单点修改）

这里是以区间最大值为例,要修改成其他的运算,注意修改每个函数的运算以及query中返回的无关值. 这里的区间最大值设置的最小元素为-1(在query中表示与当前区间不相交的区间的结果). 注意因为调用的方式传入l与r是(1,n),所以这个线段树(包括a)其实是从1开始计数的. 最后,小心爆MAXM. const int MAXM=200000; int a[MAXM+5],st[(MAXM<<2)+5]; void build(int o,int l,int r){ if(l==r) st[o

模板 - 数据结构 - ST表

区间最大值,nlogn预处理,1查询,不能动态修改. 令 $f[i][j]$ 表示 $[i,i+2^j-1]$ 的最大值. 显然, $f[i][0]=a[i]$ . 根据定义式,写出状态转移方程: $f[i][j]=max(f[i][j-1],f[i+2^{j-1}][j-1])$ . 我们可以这么理解:将区间 $[i,i+2^j-1]$ 分成相同的两部分中点即为 $(i+(i+2^j-1))/2=i+2^{j-1}-1/2$ 所以 $[i,i+2^j-1]$ 可以分成 $[i,i+2^{j-

模板 - 数据结构 - 单调队列/单调栈

一道例题,给定一串数字,求每连续k个数字的最大.最小值. 思路:初始化一个初始长度为k的单调队列,按从左到右加入元素,同时满足这个队列中的元素是递减的(也就是假如某个数被两个距离不超过k的大于他的数夹着,他会被从队尾调出队列).得到最大值. 向右移动一格,假如队首离开范围,出队.往队尾加入元素前,把队尾的所有比它小的元素全部出队. 得到新的最大值. #include<bits/stdc++.h> using namespace std; struct Monotone_Queue{ deque

模板 - 数据结构 - 线段树/SegmentTree

struct SegmentTree { #define ls (o<<1) #define rs (o<<1|1) static const int MAXN = 100000; ll a[MAXN + 5]; ll st[(MAXN << 2) + 5]; void PushUp(int o) { st[o] = st[ls] + st[rs]; } void Build(int o, int l, int r) { if(l == r) st[o] = a[l];

模板 - 数据结构 - 重链剖分

一般都是重链剖分的多,重链剖分在维护路径信息时比较优秀. 也可以使用长链剖分,使用深度最大的儿子作为"重儿子"即可,看了一下用于某种与深度有关的启发式合并比重链剖分好,等以后再研究吧. #include<bits/stdc++.h> #define lc (o<<1) #define rc (o<<1|1) typedef long long ll; using namespace std; const int MAXN = 100000 + 5;