Fhq-Treap.

  1. // Fhq-Treap
  3. const int MAXN = 1e5 + 5;
  5. struct Fhq_Treap {
  6. #define Lson Tr[p].l
  7. #define Rson Tr[p].r
  9.     struct Fhq_Node {
  10.         int l, r, Val, Key, Size;
  11.         Fhq_Node () {}
  12.         Fhq_Node (int L, int R, int V, int K, int S) {
  13.             l = L, r = R, Val = V, Key = K, Size = S;
  14.         }
  15.     } Tr[MAXN];
  16.     int Tot, Root;
  18.     Fhq_Treap () { Tot = 0, Root = 0; }
  20.     int Get(int Val) {
  21.         Tr[++Tot] = Fhq_Node (0, 0, Val, rand(), 1);
  22.         return Tot;
  23.     }
  25.     void Pull (int p) { Tr[p].Size = Tr[Lson].Size + Tr[Rson].Size + 1; }
  27.     void Split (int p, int Val, int &x, int &y) {
  28.         if (!p) {
  29.             x = 0, y = 0;
  30.             return;
  31.         }
  32.         if (Tr[p].Val <= Val)
  33.             x = p, Split (Rson, Val, Rson, y);
  34.         else
  35.             y = p, Split (Lson, Val, x, Lson);
  36.         Pull (p);
  37.     }
  39.     int Merge (int x, int y) {
  40.         if (!x || !y)
  41.             return x + y;
  42.         if (Tr[x].Key <= Tr[y].Key) {
  43.             Tr[x].r = Merge (Tr[x].r, y), Pull (x);
  44.             return x;
  45.         }
  46.         else {
  47.             Tr[y].l = Merge (x, Tr[y].l), Pull (y);
  48.             return y;
  49.         }
  50.     }
  52.     void Insert (int Val) {
  53.         int x, y;
  54.         Split (Root, Val, x, y), Root = Merge (Merge (x, Get(Val)), y);
  55.     }
  57.     void Delete (int Val) {
  58.         int x, y, z;
  59.         Split (Root, Val, x, z), Split (x, Val - 1, x, y);
  60.         y = Merge (Tr[y].l, Tr[y].r), Root = Merge (Merge (x, y), z);
  61.     }
  63.     int Get_Rank (int Val) {
  64.         int x, y, Ret;
  65.         Split (Root, Val - 1, x, y);
  66.         Ret = Tr[x].Size + 1, Root = Merge (x, y);
  67.         return Ret;
  68.     }
  70.     int Get_Val (int Rank) {
  71.         int p = Root;
  72.         while (p) {
  73.             if (Tr[Lson].Size + 1 == Rank)
  74.                 return Tr[p].Val;
  75.             else if (Rank <= Tr[Lson].Size)
  76.                 p = Lson;
  77.             else
  78.                 Rank -= (Tr[Lson].Size + 1), p = Rson;
  79.         }
  80.         return 0;
  81.     }
  83.     int Get_Pre (int Val) {
  84.         int x, y, p;
  85.         Split (Root, Val - 1, x, y), p = x;
  86.         while (Rson)
  87.             p = Rson;
  88.         int ret = Tr[p].Val;
  89.         Root = Merge (x, y);
  90.         return ret;
  91.     }
  93.     int Get_Next (int Val) {
  94.         int x, y, p;
  95.         Split (Root, Val, x, y), p = y;
  96.         while (Lson)
  97.             p = Lson;
  98.         int ret = Tr[p].Val;
  99.         Root = Merge (x, y);
  100.         return ret;
  101.     }
  103. #undef Lson
  104. #undef Rson
  105. } Tree;

Splay.

  1. struct Splay_Tree {
  2. #define Lson Tr[p].Son[0]
  3. #define Rson Tr[p].Son[1]
  4. #define Inf 0x3f3f3f3f
  6.     struct Splay_Node {
  7.         int Son[2], Val, Cnt, Size, Fa;
  8.         Splay_Node () {}
  9.         Splay_Node (int V, int C, int S, int F) {
  10.             Val = V, Cnt = C, Size = S, Fa = F;
  11.         }
  12.     } Tr[MAXN];
  14.     int Tot, Root;
  16.     bool Ident (int p) { return Tr[Tr[p].Fa].Son[1] == p; }
  18.     int Get (int Val, int Fa) {
  19.         Tr[++Tot].Fa = Fa, Tr[Tot].Cnt = Tr[Tot].Size = 1, Tr[Tot].Val = Val;
  20.         return Tot;
  21.     }
  23.     void Pull (int p) { Tr[p].Size = Tr[Lson].Size + Tr[Rson].Size + Tr[p].Cnt; }
  25.     void Build () {
  26.         Root = Get (-Inf, 0);
  27.         Tr[Root].Son[1] = Get (Inf, Root), Pull (Root);
  28.     }
  30.     void Connect (int p, int Fa, int flag) { Tr[Fa].Son[flag] = p, Tr[p].Fa = Fa; }
  32.     void Rotate (int p) {
  33.         int Fa = Tr[p].Fa, Grand = Tr[Fa].Fa;
  34.         int Flag1 = Ident (p), Flag2 = Ident (Fa);
  35.         Connect (p, Grand, Flag2), Connect (Tr[p].Son[Flag1 ^ 1], Fa, Flag1);
  36.         Connect (Fa, p, Flag1 ^ 1), Pull (Fa), Pull (p);
  37.     }
  39.     void Splay (int p, int To) {
  40.         for (int Fa = Tr[p].Fa; Tr[p].Fa != To; Rotate (p), Fa = Tr[p].Fa)
  41.             if (Tr[Fa].Fa != To)
  42.                 Ident (p) == Ident (Fa) ? Rotate (Fa) : Rotate (p);
  43.         if (!To)
  44.             Root = p;
  45.     }
  47.     int Find (int p, int Val) {
  48.         if (!p)
  49.             return 0;
  50.         if (Val == Tr[p].Val)
  51.             return p;
  52.         else if (Val < Tr[p].Val)
  53.             return Find (Lson, Val);
  54.         return Find (Rson, Val);
  55.     }
  57.     void Insert (int &p, int Val, int Fa) {
  58.         if (!p)
  59.             Splay (p = Get (Val, Fa), 0);
  60.         else if (Val == Tr[p].Val)
  61.             ++Tr[p].Cnt, Splay (p, 0);
  62.         else if (Val < Tr[p].Val)
  63.             Insert (Lson, Val, p);
  64.         else
  65.             Insert (Rson, Val, p);
  66.     }
  68.     void Delete(int Val) {
  69.         int p = Find (Root, Val);
  70.         if (!p)
  71.             return;
  72.         if (Tr[p].Cnt > 1) {
  73.             --Tr[p].Cnt, Splay (p, 0), Pull (p);
  74.             return;
  75.         }
  76.         Splay (p, 0);
  77.         int l = Lson, r = Rson;
  78.         while (Tr[l].Son[1])
  79.             l = Tr[l].Son[1];
  80.         while (Tr[r].Son[0])
  81.             r = Tr[r].Son[0];
  82.         Splay (l, 0), Splay (r, l);
  83.         Tr[r].Son[0] = 0, Pull (r), Pull (l);
  84.     }
  86.     int Get_Rank (int p, int Val) {
  87.         if (!p)
  88.             return 0;
  89.         if (Val == Tr[p].Val) {
  90.             int Res = Tr[Lson].Size + 1; Splay(p, 0);
  91.             return Res;
  92.         }
  93.         else if (Val < Tr[p].Val)
  94.             return Get_Rank (Lson, Val);
  95.         int Res = Tr[Lson].Size + Tr[p].Cnt;
  96.         return Get_Rank (Rson, Val) + Res;
  97.     }
  99.     int Get_Val (int p, int rank) {
  100.         if (!p)
  101.             return Inf;
  102.         if (Tr[Lson].Size >= rank)
  103.             return Get_Val (Lson, rank);
  104.         else if (Tr[Lson].Size + Tr[p].Cnt >= rank) {
  105.             Splay (p, 0);
  106.             return Tr[p].Val;
  107.         }
  108.         return Get_Val (Rson, rank - Tr[Lson].Size - Tr[p].Cnt);
  109.     }
  111.     int Get_Pre(int Val) {
  112.         int p = Root, Ret;
  113.         while (p) {
  114.             if (Tr[p].Val < Val)
  115.                 Ret = Tr[p].Val, p = Rson;
  116.             else
  117.                 p = Lson;
  118.         }
  119.         Splay (Root, 0);
  120.         return Ret;
  121.     }
  123.     int Get_Next(int Val) {
  124.         int p = Root, Ret;
  125.         while (p) {
  126.             if (Tr[p].Val > Val)
  127.                 Ret = Tr[p].Val, p = Lson;
  128.             else
  129.                 p = Rson;
  130.         }
  131.         Splay (Root, 0);
  132.         return Ret;
  133.     }
  135. #undef Lson
  136. #undef Rson
  137. #undef Inf 0x3f3f3f3f
  138. } Tree;

Treap.

  1. // Treap
  3. const int MAXN = 1e5 + 5;
  5. struct Treap_Tree {
  6. #define INF 0x3f3f3f3f
  7. #define mod 998244353
  8.     struct Treap_Node {
  9.         int son[2], val, dat, cnt, size;
  10. #define lson tr[p].son[0]
  11. #define rson tr[p].son[1]
  12.         Treap_Node() {}
  13.         Treap_Node(int Val, int Dat, int Cnt, int Size) {
  14.             val = Val;
  15.             dat = Dat;
  16.             cnt = Cnt;
  17.             size = Size;
  18.         }
  19.     } tr[MAXN];
  21.     int tot, root;
  23.     int Get(int val) {
  24.         tr[++tot] = Treap_Node(val, rand() % mod, 1, 1);
  25.         tr[tot].son[0] = 0;
  26.         tr[tot].son[1] = 0;
  27.         return tot;
  28.     }
  30.     void Update(int p) { tr[p].size = tr[p].cnt + tr[lson].size + tr[rson].size; }
  32.     int Get_Rank(int p, int val) {
  33.         if (!p)
  34.             return 1;
  35.         if (val == tr[p].val)
  36.             return tr[lson].size + 1;
  37.         if (val < tr[p].val)
  38.             return Get_Rank(lson, val);
  39.         return tr[lson].size + tr[p].cnt + Get_Rank(rson, val);
  40.     }
  42.     int Get_Val(int p, int r) {
  43.         if (!p)
  44.             return INF;
  45.         if (tr[lson].size >= r)
  46.             return Get_Val(lson, r);
  47.         if (tr[lson].size + tr[p].cnt >= r)
  48.             return tr[p].val;
  49.         return Get_Val(rson, r - tr[lson].size - tr[p].cnt);
  50.     }
  52.     void Rotate(int &p, int t) {
  53.         int q = tr[p].son[!t];
  54.         tr[p].son[!t] = tr[q].son[t];
  55.         tr[q].son[t] = p;
  56.         p = q;
  57.         Update(tr[p].son[t]);
  58.         Update(p);
  59.     }
  61.     void Insert(int &p, int val) {
  62.         if (!p) {
  63.             p = Get(val);
  64.             return;
  65.         }
  66.         if (val == tr[p].val) {
  67.             tr[p].cnt++;
  68.             Update(p);
  69.             return;
  70.         }
  71.         if (val < tr[p].val) {
  72.             Insert(lson, val);
  73.             if (tr[p].dat < tr[lson].dat)
  74.                 Rotate(p, 1);
  75.         } else {
  76.             Insert(rson, val);
  77.             if (tr[p].dat < tr[rson].dat)
  78.                 Rotate(p, 0);
  79.         }
  80.         Update(p);
  81.     }
  83.     int Get_Pre(int x) {
  84.         int p = root, ret = -INF;
  85.         while (p) {
  86.             if (tr[p].val <= x) {
  87.                 ret = tr[p].val;
  88.                 p = rson;
  89.             } else
  90.                 p = lson;
  91.         }
  92.         return ret;
  93.     }
  95.     int Get_Next(int x) {
  96.         int p = root, ret = INF;
  97.         while (p) {
  98.             if (tr[p].val >= x) {
  99.                 ret = tr[p].val;
  100.                 p = lson;
  101.             } else
  102.                 p = rson;
  103.         }
  104.         return ret;
  105.     }
  107.     void Delete(int &p, int val) {
  108.         if (!p)
  109.             return;
  110.         if (val == tr[p].val) {
  111.             if (tr[p].cnt > 1) {
  112.                 tr[p].cnt--;
  113.                 Update(p);
  114.                 return;
  115.             }
  116.             if (lson || rson) {
  117.                 if (rson == 0 || tr[lson].dat > tr[rson].dat) {
  118.                     Rotate(p, 1);
  119.                     Delete(rson, val);
  120.                 } else {
  121.                     Rotate(p, 0);
  122.                     Delete(lson, val);
  123.                 }
  124.                 Update(p);
  125.             } else
  126.                 p = 0;
  127.             return;
  128.         }
  129.         if (val < tr[p].val)
  130.             Delete(lson, val);
  131.         else
  132.             Delete(rson, val);
  133.         Update(p);
  134.     }
  135. #undef lson
  136. #undef rson
  137. } tree;

Template -「平衡树」的更多相关文章

  1. 「luogu3380」【模板】二逼平衡树（树套树）

    「luogu3380」[模板]二逼平衡树(树套树) 传送门 我写的树套树--线段树套平衡树. 线段树上的每一个节点都是一棵 \(\text{FHQ Treap}\) ,然后我们就可以根据平衡树的基本操 ...

  2. Template -「整体二分」

    写的简单.主要是留给自己做复习资料. 「BZOJ1901」Dynamic Rankings. 给定一个含有 \(n\) 个数的序列 \(a_1,a_2 \dots a_n\),需要支持两种操作: Q ...

  3. 「SCOI2014」方伯伯的 OJ 解题报告

    「SCOI2014」方伯伯的 OJ 和列队有点像,平衡树点分裂维护即可 但是需要额外用个set之类的对编号查找点的位置 插入完了后记得splay,删除时注意特判好多东西 Code: #include ...

  4. LOJ 3184: 「CEOI2018」斐波那契表示法

    题目传送门:LOJ #3184. 题意简述: 题目说得很清楚了. 题解: 首先需要了解「斐波那契数系」为何物. 按照题目中定义的斐波那契数列 \(F_n\),可以证明,每个非负整数 \(n\) 都能够 ...

  5. 「JSOI2011」任务调度

    「JSOI2011」任务调度 传送门 一开始还在想写平衡树,看到 \(\text{TRANS}\) 操作后就晓得要用可并堆了. 这题好像就是个可并堆的板子题??? ADD 直接往对应的对里面加元素 D ...

  6. 「NOI2005」维护数列

    「NOI2005」维护数列 传送门 维护过程有点像线段树. 但我们知道线段树的节点并不是实际节点,而平衡树的节点是实际节点. 所以在向上合并信息时要加入根节点信息. 然后节点再删除后编号要回退(栈), ...

  7. 「HNOI2004」宠物收养场

    「HNOI2004」宠物收养场 传送门 对宠物和人各维护一棵平衡树,每次 \(\text{split}\) 的时候记得判一下子树是否为空,然后模拟就好了. 参考代码: #include <alg ...

  8. 「TJOI2013」最长上升子序列

    「TJOI2013」最长上升子序列 传送门 这个 \(\text{DP}\) 应该都会撒: \[dp_i = \max_{j < i,a_j < a_i}\left\{dp_j\right ...

  9. 「C++」理解智能指针

    维基百科上面对于「智能指针」是这样描述的: 智能指针(英语:Smart pointer)是一种抽象的数据类型.在程序设计中,它通常是经由类型模板(class template)来实做,借由模板(tem ...

随机推荐

  1. Django学习——Django settings 源码、模板语法之传值、模板语法之获取值、模板语法之过滤器、模板语法之标签、自定义过滤器、标签、inclusion_tag、模板的导入、模板的继承

    Django settings 源码 """ 1.django其实有两个配置文件 一个是暴露给用户可以自定义的配置文件 项目根目录下的settings.py 一个是项目默 ...

  2. Lab_1：练习1——理解通过make生成执行文件的过程

    lab_0 清华大学ucore实验环境配置详细步骤!(小白入) lab_1 清华大学ucore bootload启动ucore os(预备知识) Lab_1:练习1--理解通过make生成执行文件的过 ...

  3. 墙裂推荐！一款 VM 大规模集群管理工具

    关注「开源Linux」,选择"设为星标" 回复「学习」,有我为您特别筛选的学习资料~ Google 发布了基础设施管理工具 VM Manager,可自动维护大型Compute En ...

  4. 论文阅读 Dynamic Graph Representation Learning Via Self-Attention Networks

    4 Dynamic Graph Representation Learning Via Self-Attention Networks link:https://arxiv.org/abs/1812. ...

  5. 老生常谈系列之Aop--Spring Aop源码解析（二）

    老生常谈系列之Aop--Spring Aop源码解析(二) 前言 上一篇文章老生常谈系列之Aop--Spring Aop源码解析(一)已经介绍完Spring Aop获取advice切面增强方法的逻辑, ...

  6. Web安全学习笔记 SQL注入中

    Web安全学习笔记 SQL注入中 繁枝插云欣 --ICML8 权限提升 数据库检测 绕过技巧 一.权限提升 1. UDF提权 UDF User Defined Function,用户自定义函数 是My ...

  7. 记录一次用宝塔部署微信小程序Node.js后端接口代码的详细过程

    一直忙着写毕设,上一次写博客还是元旦,大半年过去了.... 后面会不断分享各种新项目的源码与技术.欢迎关注一起学习哈! 记录一次部署微信小程序Node.js后端接口代码的详细过程,使用宝塔来部署. 我 ...

  8. scrapy架构与目录介绍、scrapy解析数据、配置相关、全站爬取cnblogs数据、存储数据、爬虫中间件、加代理、加header、集成selenium

    今日内容概要 scrapy架构和目录介绍 scrapy解析数据 setting中相关配置 全站爬取cnblgos文章 存储数据 爬虫中间件和下载中间件 加代理,加header,集成selenium 内 ...

  9. windows获取高精度时间戳 精度100ns

    #include <stdio.h> #include <Windows.h> int main(void){ LARGE_INTEGER ticks,Frequency; Q ...

  10. QC快速充电

    QC快充 一.高通QC快充的介绍 二.识别充电类型的芯片介绍 三.QC充电曲线 四.如何在log中看QC充电类型 五.QC3识别错误 六.波形图 一.高通QC快充的介绍 高通QC快充技术,又称Quic ...