这道题算法是二叉平衡树，要想做此题，我们要先了解一下二叉平衡树
要想了解二叉平衡树，我们要从二叉排序树说起：
二叉排序树
二叉排序树又称二叉搜索树、二叉查找树 BST
性质如下：
- 空树为二叉排序树
- 若二叉排序树的左子树不为空，则左子树上所有节点的权值都小于根节点的权值
- 若二叉排序树的右子树不为空，则右子树上所有节点的权值都大于根节点的权值
- 二叉排序树的左右子树均为二叉排序树
退化：如果建树的元素均为有序，退化成链式的结构。
二叉排序树单次查找复杂度O(logn)，退化成链式的结构时为O(n)
为了防止二叉排序树退化，我们创造了一种数据结构——二叉平衡树
二叉平衡树有如下几种方式：
- 替罪羊树
- Treap树
- Splay树
- AVL树
- 红黑树
- SBT树
这里我们讲解Treap树
Treap树
Tree + Heap 。满足二叉排序树与二叉堆的两种性质。
树堆（Treap）
核心思想：用优先级来维护二叉树的平衡性。
应用：维护序列，元素的定位。修改、删除穿插在查询中。
- 寻找名次
- 确定<x的最大值
- 确定>x的最小值
Treap树的操作基于 "键值"+"优先级"。
优先级：赋予节点一个随机的优先级。
键值：二叉排序树 优先级：二叉堆
对于任意的一组节点：fa父节点，ls左孩子节点,rs右孩子节,满足特性：
- 键值满足二叉排序树特征：ls.val<fa.val<rs.val
- 优先级满足二叉堆特征：fa.pri>max(ls.pri,rs.pri)
重要性质：若每个节点的键值、优先级提前确定好，那么构成的BST的形态唯一，与插入顺序无关。
Treap单次操作复杂度为O(logn)，n次为O(nlogn)
旋转法维护平衡树
平衡树旋转
左旋：
- 将k作为根节点
- 将x作为k的左孩子
- 将k的的左孩子称为x的右孩子
右旋：
- 将k作为新的根节点
- 将x作为k的右孩子
- 将原来k的右孩子作为x的左孩子
代码实现：
struct node{
int val;//键值
int pri;//优先级
int size;//节点信息
int ls,rs;//左、右孩子
}t[N];
void rotate(int &x,int d){//d=0右旋 d=1左旋
int k;
if(d==0){//右旋操作
//将x围绕左孩子k，右旋至k的右孩子节点位置
// k的右子树成为x的左子树
k=t[x].ls;
t[x].ls=t[k].rs;
t[k].rs=x;
}else{//左旋操作
//将x围绕右孩子k,左旋至k的左孩子节点位置
//k的左孩子称为x的右孩子
k=t[x].rs;
t[x].rs=t[k].ls;
t[k].ls=x;
}
//更新
}插入节点
- 从根节点u开始遍历，若u为空，则创建新的节点存储元素值x.并给新节点附加随机数作为优先级
- 若x大于等于u的值，则在u的右子树上递归插入。回溯时做旋转调整。若u的优先级小于其右子节点的优先级，则u左旋。
- 若x小于u的值，则在u的左子树上递归插入。回溯时，做旋转调整。若u的优先级小于他的左子结点的优先级，则右旋。
int newNode(int x)
{
cnt ++;
t[cnt].size = 1;
t[cnt].ls = t[cnt].rs = 0;
t[cnt].val = x;
t[cnt].pri = rand();
return cnt;
}
void insert(int &u,int x){
if(u==0){
u=newNode(x);//创建新节点，并存储x至新节点中
//并返回新节点的下标
return;
}
t[u].size++;
//若x大于等于u的键值，则递归插入右子树
if(x>=t[u].val) insert(t[u].rs,x);
else insert(t[u].ls,x);
//回溯时，需要旋转调整
if(t[u].ls!=0 && t[u].pri<t[ t[u].ls ].pri) rotate(u,0);
if(t[u].rs!=0 && t[u].pri<t[ t[u].rs ].pri) rotate(u,1);
//更新调整后的节点信息
update(u);
}删除节点
- 找到此节点
- 若此节点是叶节点，直接删除
- 若此节点只有一个子树，将子树上移
- 若此节点有两个子树，向下旋转,偏向优先级更高的
void del(int &u,int x){
t[u].size--;
if(t[u].key==x){//找到键值为x的节点
//当前节点为叶子结点
if(!t[u].ls && !t[u].rs){u=0;return;}
//只有一棵子树，将子树上移
if(!t[u].ls || !t[u].rs){u=t[u].ls+t[u].rs;return;}
//向下旋转,偏向优先级更高的
if(t[t[u].ls].pri>t[t[u].rs].pri){//左子节点优先级大于右子节点的优先级
//右旋,在u的右子树中递归删除
rotate(u,0);
del(t[u].rs,x);
return ;
}else{//左子结点优先级小于右子节点的优先级
//左旋，继续在u的左子树中递归删除
rotate(u,1);
del(t[u].ls,x);
return ;
}
}
//若val小于u的值，则在u的左子树中递归删除
if(x<t[u].key) del(t[u].ls,x);
else del(t[u].rs,x);//若val大于等于p的值，则在p的右子树中递归删除
update(u);
}然后是查询x数的排名，查询排名为x的数，查询x的前驱，查询x的后继，详细操作见注释
int Rank(int u,int x){//查找x的排名
if(u==0) return 0;//是根直接输出
if(x>t[u].key) return t[t[u].ls].size+1+Rank(t[u].rs,x);//若比根大，则排名为左子树结点个数+根节点+右子树排名
return Rank(t[u].ls,x);//若比根小，则为左子树排名
}
int kth(int u,int k){查询排名为x的数
if(k==t[t[u].ls].size+1) return t[u].key;//若现排名正确（左子树结点个数+根节点），则输出
else if(k>t[t[u].ls].size+1) return kth(t[u].rs,k-t[t[u].ls].size-1);//若现排名大，则继续递归右子树，还需要减少的排名为k-左子树结点个数-根节点
else return kth(t[u].ls,k);//若现排名小，则递归左子树
}
int precursor(int u,int x){//前驱
if(u==0) return 0;//是根直接输出
if(t[u].key>=x) return precursor(t[u].ls,x);//如果值大，找左子树
int tmp=precursor(t[u].rs,x);//递归右子树
if(tmp==0) return t[u].key;//如果是根直接输出
return tmp;//不是返回tmp
}
int successor(int u,int x){//后继
if(u==0) return 0;//是根直接输出
if(t[u].key<=x) return successor(t[u].rs,x);//如果值小，找右子树
int tmp=successor(t[u].ls,x);//递归左子树
if(tmp==0) return t[u].key;//如果是根直接输出
return tmp;//不是返回tmp
}最后是模板
#include <bits/stdc++.h>
using namespace std;
const int M=1e5+5;
struct node{
int ls,rs;//左、右孩子
int key,pri;//键值、优先级
int size;//当前节点为根的子树的节点数
}t[M];
int cnt=0;//t[cnt] 最新的节点
void newNode(int x){//初始化新节点
t[++cnt].key=x;//处理键值
t[cnt].size=1;//初始化子树个数
t[cnt].pri=rand();//生成随机的优先级
}
void update(int u){//更新以u为根的子树的size
t[u].size=t[t[u].ls].size+t[t[u].rs].size+1;
}
void rotate(int &o,int d){//旋转，d=0右旋，d=1左旋
int k;
if(d==1){
//左旋，把o围绕右儿子k向左旋转至k的左孩子处，原k的左孩子成为o的右孩子
k=t[o].rs;//获取o的右儿子信息，存入k
t[o].rs=t[k].ls;//将k的左孩子接入成为o的右孩子
t[k].ls=o;//o成为k的左孩子
}else{
//右旋，将o围绕左儿子k,右旋至k的右孩子位置,原k的右子树成为o的左孩子
k=t[o].ls;//获取o的左儿子信息，存入k
t[o].ls=t[k].rs;//将k的右孩子接入成为o的左孩子
t[k].rs=o;//o成为k的右孩子
}
t[k].size=t[o].size;//更新当前孩子节点k的结点数信息
update(o);//更新当前根节点o的节点数信息
o=k;//新的根是k
}
void insert(int &u,int x){
if(u==0){newNode(x);u=cnt;return;}//递归到了一个空叶子，新建节点
t[u].size++;
if(x>=t[u].key) insert(t[u].rs,x);//递归右子树找空叶子,直到插入
else insert(t[u].ls,x);//递归左子树找空叶子，直到插入
//回溯时做旋转调整，若u的优先级小于其左子节点的优先级，则u右旋
if(t[u].ls!=0 && t[u].pri<t[t[u].ls].pri) rotate(u,0);//右旋
//回溯时做旋转调整，若u的优先级小于其右子结点的优先级，则u左旋
if(t[u].rs!=0 && t[u].pri<t[t[u].rs].pri) rotate(u,1);//左旋
update(u);
}
void del(int &u,int x){
t[u].size--;
if(t[u].key==x){//找到键值为x的节点
//当前节点为叶子结点
if(!t[u].ls && !t[u].rs){u=0;return;}
//只有一棵子树，将子树上移
if(!t[u].ls || !t[u].rs){u=t[u].ls+t[u].rs;return;}
//向下旋转,偏向优先级更高的
if(t[t[u].ls].pri>t[t[u].rs].pri){//左子节点优先级大于右子节点的优先级
//右旋,在u的右子树中递归删除
rotate(u,0);
del(t[u].rs,x);
return ;
}else{//左子结点优先级小于右子节点的优先级
//左旋，继续在u的左子树中递归删除
rotate(u,1);
del(t[u].ls,x);
return ;
}
}
//若val小于u的值，则在u的左子树中递归删除
if(x<t[u].key) del(t[u].ls,x);
else del(t[u].rs,x);//若val大于等于p的值，则在p的右子树中递归删除
update(u);
}
int Rank(int u,int x){//查找x的排名
if(u==0) return 0;
if(x>t[u].key) return t[t[u].ls].size+1+Rank(t[u].rs,x);
return Rank(t[u].ls,x);
}
int kth(int u,int k){
if(k==t[t[u].ls].size+1) return t[u].key;
else if(k>t[t[u].ls].size+1) return kth(t[u].rs,k-t[t[u].ls].size-1);
else return kth(t[u].ls,k);
}
int precursor(int u,int x){
if(u==0) return 0;
if(t[u].key>=x) return precursor(t[u].ls,x);
int tmp=precursor(t[u].rs,x);
if(tmp==0) return t[u].key;
return tmp;
}
int successor(int u,int x){
if(u==0) return 0;
if(t[u].key<=x) return successor(t[u].rs,x);
int tmp=successor(t[u].ls,x);
if(tmp==0) return t[u].key;
return tmp;
}
int main(){
srand(time(NULL));
return 0;
}黑匣子
这道题稍微分析，可知要运用二叉平衡树的插入与查找x的排名操作
先读入Add和Get，将Get从小到大排序
按顺序插入Add，每到Get时输出第k大即可
代码如下：
#include<bits/stdc++.h>
using namespace std;
struct node{
int val;
int pri;
int size;
int ls,rs;
}t[200005];
int cnt,k;
int a[200005],b[200005];
int newNode(int x)
{
cnt ++;
t[cnt].size = 1;
t[cnt].ls = t[cnt].rs = 0;
t[cnt].val = x;
t[cnt].pri = rand();
return cnt;
}
void update(int u)
{
t[u].size = t[t[u].ls].size + t[t[u].rs].size + 1;
}
void rotate(int &x, int d)
{
int k;
if(d == 0)
{
k = t[x].ls;
t[x].ls = t[k].rs;
t[k].rs = x;
}
else
{
k = t[x].rs;
t[x].rs = t[k].ls;
t[k].ls = x;
}
t[k].size = t[x].size;
update(x);
x = k;
}
void insert(int &u, int x)
{
if(u == 0)
{
u = newNode(x);
return;
}
t[u].size ++;
if(x >= t[u].val)
{
insert(t[u].rs, x);
}
else
{
insert(t[u].ls, x);
}
if(t[u].ls != 0 && t[u].pri < t[t[u].ls].pri)
{
rotate(u, 0);
}
if(t[u].rs != 0 && t[u].pri < t[t[u].rs].pri)
{
rotate(u, 1);
}
update(u);
}
void del(int &u,int x){
t[u].size --;
if(t[u].val == x)
{
if(!t[u].ls && !t[u].rs){u = 0; return;}
if(!t[u].ls || !t[u].rs){u = t[u].ls + t[u].rs; return;}
if(t[t[u].ls].pri > t[t[u].rs].pri)
{
rotate(u, 0);
del(t[u].rs, x);
return ;
}else
{
rotate(u, 1);
del(t[u].ls, x);
return;
}
}
if(x < t[u].val) del(t[u].ls, x);
else del(t[u].rs, x);
update(u);
}
int Rank(int u, int x)
{
if(u == 0) return 0;
if(x > t[u].val) return t[t[u].ls].size + 1 + Rank(t[u].rs, x);
return Rank(t[u].ls, x);
}
int kth(int u, int k)
{
if(k == t[t[u].ls].size + 1) return t[u].val;
else if(k > t[t[u].ls].size + 1) return kth(t[u].rs, k - t[t[u].ls].size - 1);
else return kth(t[u].ls, k);
}
int precursor(int u, int x)
{
if(u == 0) return 0;
if(t[u].val >= x) return precursor(t[u].ls, x);
int tmp = precursor(t[u].rs, x);
if(tmp == 0) return t[u].val;
return tmp;
}
int successor(int u, int x)
{
if(u == 0) return 0;
if(t[u].val <= x) return successor(t[u].rs, x);
int tmp = successor(t[u].ls, x);
if(tmp == 0) return t[u].val;
return tmp;
}
int main()
{
srand(time(NULL));
int n,m,root=0;
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>a[i];
for(int i=1;i<=m;i++) cin>>b[i];
sort(b+1,b+m+1);
for(int i=1;i<=m;i++)
{
for(int j=b[i-1]+1;j<=b[i];j++) insert(root,a[j]);
cout<<kth(root,++k)<<"\n";
}
return 0;
}
66
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
