模板 - 可持久化无旋Treap

最新推荐文章于 2020-08-21 23:13:50 发布
最新推荐文章于 2020-08-21 23:13:50 发布
阅读量82 收藏
点赞数
原文链接：http://www.cnblogs.com/Yinku/p/11330360.html
版权

空间消耗非常玄学，有多大开多大就完事了。其实是因为单次操作可能会有数次Merge和Split操作，按照下面的版本的话Merge和Split都进行复制，所以一次操作可能复制了4个版本。
四个函数式查询，然后Merge的时候拷贝对应的xy子树，Split的时候拷贝p树。事实上，Merge和Split总是成对出现，只需要在其中喜欢的一个进行可持久化（复制节点）就可以了，比较推荐在Split的时候复制节点。这样单次操作大概复制2个版本。

#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 = 30000000 + 5;
int val[MAXN], ch[MAXN][2], rnd[MAXN], siz[MAXN], tot, root[MAXN];

void Init() {
    tot = 0;
    memset(root,0,sizeof(root));
}

int NewNode(int v) {
    ++tot;
    ch[tot][0] = ch[tot][1] = 0;
    val[tot] = v, rnd[tot] = rand();
    siz[tot] = 1;
    return tot;
}

int CopyNode(int p) {
    ++tot;
    ch[tot][0] = ch[p][0];
    ch[tot][1] = ch[p][1];
    val[tot] = val[p];
    rnd[tot] = rnd[p];
    siz[tot] = siz[p];
    return tot;
}

void PushUp(int p) {
    siz[p] = siz[ls(p)] + siz[rs(p)] + 1;
}

void SplitValue(int p, int v, int &x, int &y) {
    if(!p) {
        x = y = 0;
        return;
    }
    if(v < val[p]) {
        y = CopyNode(p);
        SplitValue(ls(y), v, x, ls(y));
        PushUp(y);
    } else {
        x = CopyNode(p);
        SplitValue(rs(x), v, rs(x), y);
        PushUp(x);
    }
}

/*void SplitRank(int p, int rk, int &x, int &y) {
    if(!p) {
        x = y = 0;
        return;
    }
    if(rk <= siz[ls(p)]) {
        y = p;
        SplitRank(ls(p), rk, x, ls(p));
        PushUp(y);
    } else {
        x = p;
        SplitRank(rs(p), rk - siz[ls(p)] - 1, rs(p), y);
        PushUp(x);
    }
}*/

int Merge(int x, int y) {
    if(!x || !y)
        return x | y;
    if(rnd[x] < rnd[y]) {
        int p = CopyNode(x);
        rs(p) = Merge(rs(p), y);
        PushUp(p);
        return p;
    } else {
        int p = CopyNode(y);
        ls(p) = Merge(x, ls(p));
        PushUp(p);
        return p;
    }
}

void Insert(int &root, int v) {
    int x = 0, y = 0;
    SplitValue(root, v, x, y);
    root = Merge(Merge(x, NewNode(v)), y);
}

void Remove(int &root, int v) {
    int x = 0, y = 0, z = 0;
    SplitValue(root, v, x, z);
    SplitValue(x, v - 1, x, y);
    y = Merge(ls(y), rs(y));
    root = Merge(Merge(x, y), z);
}

int GetRank2(int p, int v) {
    int rk = 1;
    while(p) {
        if(v < val[p])
            p = ls(p);
        else if(v == val[p])
            p = ls(p);
        else {
            rk += siz[ls(p)] + 1;
            p = rs(p);
        }
    }
    return rk;
}

int GetValue2(int p, int rk) {
    while(p) {
        if(rk <= siz[ls(p)])
            p = ls(p);
        else if(rk == siz[ls(p)] + 1)
            return val[p];
        else {
            rk -= siz[ls(p)] + 1;
            p = rs(p);
        }
    }
}

int GetPrev2(int p, int v) {
    int prev;
    while(p) {
        if(v <= val[p])
            p = ls(p);
        else {
            prev = val[p];
            p = rs(p);
        }
    }
    return prev;
}

int GetNext2(int p, int v) {
    int next;
    while(p) {
        if(v < val[p]) {
            next = val[p];
            p = ls(p);
        } else
            p = rs(p);
    }
    return next;
}

int main() {
#ifdef Yinku
    freopen("Yinku.in", "r", stdin);
#endif // Yinku
    int n;
    scanf("%d", &n);
    Init();
    for(int i = 1; i <= n; ++i) {
        int v,op, x;
        scanf("%d%d%d",&v, &op, &x);
        root[i]=root[v];
        switch(op) {
            case 1:
                Insert(root[i], x);
                break;
            case 2:
                Remove(root[i], x);
                break;
            case 3:
                printf("%d\n", GetRank2(root[i], x));
                break;
            case 4:
                printf("%d\n", GetValue2(root[i], x));
                break;
            case 5:
                printf("%d\n", GetPrev2(root[i], x));
                break;
            case 6:
                printf("%d\n", GetNext2(root[i], x));
                break;
        }
    }
    return 0;
}
#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 = 20000000 + 5;
int val[MAXN], ch[MAXN][2], rnd[MAXN], siz[MAXN], tot, root[MAXN];

void Init() {
    tot = 0;
    memset(root,0,sizeof(root));
}

int NewNode(int v) {
    ++tot;
    ch[tot][0] = ch[tot][1] = 0;
    val[tot] = v, rnd[tot] = rand();
    siz[tot] = 1;
    return tot;
}

int CopyNode(int p) {
    ++tot;
    ch[tot][0] = ch[p][0];
    ch[tot][1] = ch[p][1];
    val[tot] = val[p];
    rnd[tot] = rnd[p];
    siz[tot] = siz[p];
    return tot;
}

void PushUp(int p) {
    siz[p] = siz[ls(p)] + siz[rs(p)] + 1;
}

void SplitValue(int p, int v, int &x, int &y) {
    if(!p) {
        x = y = 0;
        return;
    }
    if(v < val[p]) {
        y = CopyNode(p);
        SplitValue(ls(y), v, x, ls(y));
        PushUp(y);
    } else {
        x = CopyNode(p);
        SplitValue(rs(x), v, rs(x), y);
        PushUp(x);
    }
}

/*void SplitRank(int p, int rk, int &x, int &y) {
    if(!p) {
        x = y = 0;
        return;
    }
    if(rk <= siz[ls(p)]) {
        y = p;
        SplitRank(ls(p), rk, x, ls(p));
        PushUp(y);
    } else {
        x = p;
        SplitRank(rs(p), rk - siz[ls(p)] - 1, rs(p), y);
        PushUp(x);
    }
}*/

int Merge(int x, int y) {
    if(!x || !y)
        return x | y;
    if(rnd[x] < rnd[y]) {
        //int p = CopyNode(x);
        int p=x;
        rs(p) = Merge(rs(p), y);
        PushUp(p);
        return p;
    } else {
        int p=y;
        //int p = CopyNode(y);
        ls(p) = Merge(x, ls(p));
        PushUp(p);
        return p;
    }
}

void Insert(int &root, int v) {
    int x = 0, y = 0;
    SplitValue(root, v, x, y);
    root = Merge(Merge(x, NewNode(v)), y);
}

void Remove(int &root, int v) {
    int x = 0, y = 0, z = 0;
    SplitValue(root, v, x, z);
    SplitValue(x, v - 1, x, y);
    y = Merge(ls(y), rs(y));
    root = Merge(Merge(x, y), z);
}

int GetRank2(int p, int v) {
    int rk = 1;
    while(p) {
        if(v < val[p])
            p = ls(p);
        else if(v == val[p])
            p = ls(p);
        else {
            rk += siz[ls(p)] + 1;
            p = rs(p);
        }
    }
    return rk;
}

int GetValue2(int p, int rk) {
    while(p) {
        if(rk <= siz[ls(p)])
            p = ls(p);
        else if(rk == siz[ls(p)] + 1)
            return val[p];
        else {
            rk -= siz[ls(p)] + 1;
            p = rs(p);
        }
    }
}

int GetPrev2(int p, int v) {
    int prev;
    while(p) {
        if(v <= val[p])
            p = ls(p);
        else {
            prev = val[p];
            p = rs(p);
        }
    }
    return prev;
}

int GetNext2(int p, int v) {
    int next;
    while(p) {
        if(v < val[p]) {
            next = val[p];
            p = ls(p);
        } else
            p = rs(p);
    }
    return next;
}

int main() {
#ifdef Yinku
    freopen("Yinku.in", "r", stdin);
#endif // Yinku
    int n;
    scanf("%d", &n);
    Init();
    for(int i = 1; i <= n; ++i) {
        int v,op, x;
        scanf("%d%d%d",&v, &op, &x);
        root[i]=root[v];
        switch(op) {
            case 1:
                Insert(root[i], x);
                break;
            case 2:
                Remove(root[i], x);
                break;
            case 3:
                printf("%d\n", GetRank2(root[i], x));
                break;
            case 4:
                printf("%d\n", GetValue2(root[i], x));
                break;
            case 5:
                printf("%d\n", GetPrev2(root[i], x));
                break;
            case 6:
                printf("%d\n", GetNext2(root[i], x));
                break;
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/Yinku/p/11330360.html

weixin_30882895
关注
可持久化无旋treap（良心讲解 P3835）
shadiao.的博客
09-23 365
前置技能：无旋treap 什么是可持久化平衡树？ 每经过一次操作，当前状态的整棵树就成为一棵全新版本的树，给每个版本编个号，我们可以根据版本号查找这格版本的树中的一些信息，也可以在这个版本上进行修改生成全新版本。 我们需要保留每个版本的所有信息。 可持久化无旋treap的大体思想 由于treap的树的期望深度为O（logn）级别，所以每次操作（插入/删除等）只涉及O（logn）个节点的修...
无旋treap（可持久化，区间操作），解决普通平衡树、文艺平衡树
avenLJY的博客
05-23 847
无旋treap 普通平衡树tyvj1728（treap模板） 如果想看旋转treap怎么写戳这儿 无旋treap代码： #include<bits/stdc++.h> using namespace std; const int N=5e5+5; struct node{ int val,ch[2],size,rd; #define l(x) t[x].ch[0] #define...
非旋Treap及其可持久化
A1847225889的博客
02-17 374
平衡树这种东西，我只会splay。splay比较好理解，并且好打，操作方便。 我以前学过SBT，但并不是很理解，所以就忘了怎么打了。 许多用平衡树的问题其实可以用线段树来解决，我们真正打平衡树的时候一般都是维护序列之类的。 维护序列时，splay特别方便，所以一般情况下打splay就好了。其它的平衡树也可以，可是如果见到翻转操作的时候，那些平衡树就会崩（至少我不知道那些平衡树有什么可以翻转的做法）...
无旋Treap的可持久化
Daniel__d的博客
03-29 160
无旋Treap的可持久化 解析 其实FHQTreapFHQ TreapFHQTreap的可持久化非常好理解，只需要的每次操作的rtrtrt用数组记录下来，然后操作时，节点新建即可 模板题 P3835 注意操作细节 注意数组大小 注意rand()rand()rand()的值域 代码 #include<bits/stdc++.h> #define int long long #define...
可持久化非旋Treap
某司机的黑车
09-18 301
#普通非旋Treap 看这里
(可持久化无旋Treap / stl)
CUCUC1的博客
08-08 372
1、利用可持久化无旋Treap 2、利用c++的stl容器crope，内部是用平衡树实现的，操作都是O（logN） 这里直接转了别人的代码 代码出处传送门 #include<iostream> #include<cstdio> #include<ext/rope> #include<string> using namespace std; using namespace __gnu_cxx; const int maxn=50005; crope ro,
模板 - FHQ - treap 无旋平衡树
繁凡さん的博客
08-21 712
整理的算法模板合集： ACM模板 #include<bits/stdc++.h> using namespace std; const int N = 100007; int n, m, tot, root; struct node{ int l, r; int key;//权值 int val;//平衡因子 int size;//子树个数 }tr[N]; void pushup(int p){ tr[p].size = tr[tr[p].l]
无旋treap/fhq-treap 模板 （附良心讲解 + 例题：洛谷P3369 普通平衡树）
shadiao.的博客
09-09 752
博文更新： 20190917 更新了一下merge和split函数的递归理解 定义： 无旋treap，就是不通过旋转的维护堆性质的treap，根本的原理还是 tree + heap。 与普通treap的不同之处： 大概就是可以可持久化。 然后区间操作的话，不知道有旋的行不行，用无旋的反正是比较好搞，区间操作举个例子就是让你把一段区间的数反过来等等。 现在听着可能区间操作什么的可能莫名...
浅谈无旋treap(fhq_treap)
aaa3201的博客
06-01 1449
一、简介 无旋Treap（fhq_treap），是一种不用旋转的treap，其代码复杂度不高，应用范围广（能代替普通treap和splay的所有功能），是一种极其强大的平衡树。 无旋Treap是一个叫做范浩强的大佬发明的（快%啊！） 在我们一起学习无旋Treap之前，本蒟蒻有几句活想说： 1.无旋Treap我个人认为是最容易理解的一种平衡树，而且编程复杂度不高，功能还那么强大。 ...
【模板】可持久化平衡树（非旋Treap）
远行客
03-23 1389
洛谷传送门：【模板】可持久化平衡树 题意 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作（对于各个以往的历史版本）： 1.插入x数 2.删除x数(若有多个相同的数，因只删除一个，如果没有请忽略该操作) 3.查询x数的排名(排名定义为比当前数小的数的个数+1。若有多个相同的数，因输出最小的排名) 4.查询排名为x的数 5.求x的前驱(前驱定义为小于x...
可持久化无旋Treap学习
StaroForgin的博客
12-02 176
可持久化无旋Treap 今天又学习了可持久化非旋Treap，其实很简单，将普通的非旋Treap持久化一遍就行了。具体来说，就是将每次操作后得到的树记录下来，每次需要改变一个点的信息时，将原有的点的信息记录下来，建一个新点去更改它的信息。 其实持久化的过程与线段树的持久化相似。 其实打出来跟普通的非旋Treap差不多，加几个改点的步骤即可。 非旋Treap学习见此处：非旋Treap学习 模...
可持久化平衡树： 无旋Treap
一位蒟蒻的小博客
08-15 394
例题 jzoj3658文本编辑器 无旋Treap 有旋Treap由于splay的存在而无用武之地了。 优点：代码较短，原生支持区间分裂合并，并支持可持久化。 缺点：较splay大概有2的常数。 核心操作 定义请戳 split(root,x) 将树root分解为两颗树，第一颗为其中[1,x]，第二颗为[x+1,size] 返回是保存上述两个根的pair。 merge(a,...
可持久化Treap
Joky_2002的博客
05-15 901
可持久化treap主要是建立在无旋treap的基础上（好像这种东西也叫fhq treap？通过新建节点等常规操作来达到可持久化的目的下面先来介绍一下可持久化treap的两个常规操作：1、split能把一颗treap o给分成小等k和大于k的两个部分，然后把两个部分分别用x和y来存储，观察发现这样分其实就像一刀砍下去，把treap分成两半，然后需要拼接进x和y的实际上只有这一刀会波及到的节点然后我们...
BZOJ3224无旋treap
kangdi的博客
10-30 152
先diss一波洛谷P3835 这道题数据巨弱 写了一个假的可持久化treap 居然过了 导致之后真正的可持久化treap疯狂wa 最后选择放弃这道题 换了LOJ的一道模板题 普通的无旋treap还是比较简单的 BZOJ3224 #include&lt;bits/stdc++.h&gt; using namespace std; const int maxn=1e5+5; struct n...
vmware workstatiions pro 17.6.1个人使用免费，不用证书直接安装使用
11-18
虚拟机vmware workstatiions pro 17.6.1个人使用免费，不用证书直接安装使用
scipy-1.2.0-cp35-cp35m-linux_armv7l.whl
11-18
scipy-1.2.0-cp35-cp35m-linux_armv7l.whl
基于springboot爬虫高考志愿智能推荐系统源码数据库文档.zip
最新发布
11-18
基于springboot爬虫高考志愿智能推荐系统源码数据库文档.zip
bimdata_api_client-4.3.0-py3-none-any.whl
11-18
bimdata_api_client-4.3.0-py3-none-any.whl
Pillow-7.0.0-cp37-cp37m-linux_armv7l.whl
11-18
Pillow-7.0.0-cp37-cp37m-linux_armv7l.whl
Python与OpenCV实现目标计数及Treap持久化技术
文章提到了 Treap 数据结构在插入、删除操作中的优势，以及如何通过可持久化处理复制Treap时保持平衡。此外，还介绍了Finger Search的概念，这是一种优化查找效率的技术，特别是在数据结构如Splay Tree中。文中还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值