BZOJ3224+洛谷3369普通平衡树 splay版

最新推荐文章于 2018-09-16 17:11:34 发布
最新推荐文章于 2018-09-16 17:11:34 发布
阅读量387 收藏
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Timsei/article/details/72599164
版权

3224: Tyvj 1728 普通平衡树

Time Limit: 10 Sec
Memory Limit: 128 MB
Submit: 12714 Solved: 5427
[Submit][Status][Discuss] Description

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：
1. 插入x数
2. 删除x数(若有多个相同的数，因只删除一个)
3. 查询x数的排名(若有多个相同的数，因输出最小的排名)
4. 查询排名为x的数
5. 求x的前驱(前驱定义为小于x，且最大的数)
6. 求x的后继(后继定义为大于x，且最小的数)

Input

第一行为n，表示操作的个数,下面n行每行有两个数opt和x，opt表示操作的序号(1<=opt<=6)

Output

对于操作3,4,5,6每行输出一个数，表示对应答案

Sample Input

10

1 106465

4 1

1 317721

1 460929

1 644985

1 84185

1 89851

6 81968

1 492737

5 493598

Sample Output

106465

84185

492737

HINT

1.n的数据范围：n<=100000

2.每个数的数据范围：[-2e9,2e9]
这是一道模板题，调了一上午+半个下午，调出无数错误最后AC，懂得了splay树的基础用法，理解了双旋的含义
splay(int x,int ff)表示将编号为x的节点转到ff的儿子，ff=0表示转到根。rotate（x）表示将x上旋一个，
splay核心代码：

void splay(int x,int ff) {
for(int F;(F=fa[x])!=ff;rotate(x))
{
if(fa[F])
{
if(!((gets(F))^(gets(x)))) rotate(F);
else rotate(x);
}
}
if(!ff) root=x; }

我们基于以下规则进行操作：

1、如果x本来就是ff的儿子直接跳出循环，完毕（因为他会先判条件再执行改变操作，所以这种情况他会直接跳出）
2、如果他的爸爸的爸爸是ff的儿子，就直接上旋一次即可。
若非以上两种 就先转一次，然后不停执行3，直到是以上以上两种。
3、他的爸爸的爸爸并不是ff的儿子那就分类讨论
》》1：要是他爸爸是他的爷爷的左儿子，他是他爸爸的左儿子（或他爸爸是他的爷爷的右儿子，他是他爸爸的右儿子）–>先转一次它爸爸，再转一次他（有利于复杂度，大家可以自己证证）。
》》2、否则就把他转两次。
这样就可以了。
（PS：这并非最好的旋转方法，但绝对不会差很多也不会被卡成n^2，这也是为了省代码）

标准的转法：先判1，在判2；如果不是就比上述方法少了一步先把x转一次的步骤，直接跳到3，一直转直到命题2成立。

上述有一个gets函数，这是用来判是左儿子还是右儿子的（其实就是为了省代码，偷懒）。

int gets(int x)
{
return (ch[fa[x]][1]==x);
}

1表示是右儿子，0表示是左儿子。这么做可以省代码，又十分简洁。
接下来呢，我们来看看rotate操作，这个是splay的核心


> void rotate(int x)
{
    int F=fa[x];
    int d=gets(x);
    int GF=fa[F];
    int dd=gets(F);
    if(GF)
    ch[GF][dd]=x;
    ch[F][d]=ch[x][!d];
    fa[ch[x][!d]]=F;
    ch[x][!d]=F;
    fa[x]=GF;
    fa[F]=x;
    pushup(F);pushup(x);
    return;
}

其实就是先判这是左旋还是右旋，然后代码应该看得懂，这样换下儿子换下位置，仍满足BST性质，所以可以这么做，我们旋转这棵树可以防止其退化，并且方便操作。最后别忘记pushup统计下这两个节点的包括自己的子树所含的节点个数。顺序不能换，因为现在F是x的儿子了，且为防止0对结果的影响，S[x]表示这两个节点的包括自己的子树所含的节点个数，num[x]是该重复节点的个数，所以有了以下代码
-

void pushup(int x){S[0]=0;S[x]=S[ch[x][0]]+S[ch[x][1]]+num[x];return;}

现在我们对splay的核心操作已经了如指掌，现在我们可以开始进行操作了，我们支持题中所说的所有操作：
1、insert

void insert(int dd)
{
if(size==0||root==0)
{
num[++size]=1;
S[size]=1;
val[size]=dd;
root=1;
fa[size]=0;
return;
}
int ll=find(dd);
if(val[ll]!=dd)
{
val[++size]=dd;
num[size]=0;
fa[size]=ll;
if(dd<val[ll]) ch[ll][0]=size;else ch[ll][1]=size;
ch[size][0]=ch[size][1]=0;
ll=size;
}
splay(ll,0);
num[ll]++;
pushup(ll);
}

第一句话好理解，要是该树是空的那就造一棵树，自己当根节点。（其实不用特判直接删了都能过）
然后就是找值为dd的点，如果有就直接num[ll]++,没有就创一个新的节点，注意find会自动返回添加节点的父亲。记录一下val值这样就能OK了。
2、del删除操作

void del(int x)
{
int node=find(x);
splay(node,0);
num[node]--;
if(num[node]==0)
{
if(!ch[node][0]&&!ch[node][1])root=0;
else if(!ch[node][0])
{
root=ch[node][1];fa[ch[node][1]]=0;
}
else if(!ch[node][1])
{
root=ch[node][0];fa[ch[node][0]]=0;
}
else
{
int ll=succ(node);
fa[ch[node][0]]=0;
splay(ll,0);
fa[ch[node][1]]=ll;
ch[ll][1]=ch[node][1];
pushup(ll);
}
}
}

删除操作先将其找到，把他旋到根，然后就看他是否有两个儿子，如果他有，那么我们就可以直接做，否则我们先把他删了，分成左、右两颗子树，找到他的前驱，从树中转到根处（这样他一定没有右儿子）再把右子树接到该树上即可。
3、查询一个数的排名，利用size把他旋到树根然后直接统计左子树个数+1（BST性质）即可

int ll=find(it);splay(ll,0);printf("%d\n",S[ch[root][0]]+1);

4、这个也是利用BST的性质

int element(int k)
{
int r=root;
while(1)
{
if(S[ch[r][0]]<k&&S[ch[r][0]]+num[r]>=k) return r;
if(S[ch[r][0]]>=k) r=ch[r][0];
else if(S[ch[r][1]]) {k-=num[r]+S[ch[r][0]];r=ch[r][1];}
}
}

5、6、求前驱，后缀，先把他加入，然后做完前驱（后缀）后将其删除（利用BST性质）。

int succ(int node)
{
int r=ch[node][0];
while(ch[r][1]) r=ch[r][1];
return r;
}
int pred(int node)
{
int r=ch[node][1];
while(ch[r][0]) r=ch[r][0];
return r;
}

以下贴上源代码

#include<bits/stdc++.h>
using namespace std;
#define N 1000001
int num[N],S[N],key[N],fa[N],ch[N][2],val[N];
int n,m;
int opt,it,root,size=0;
void pushup(int x){S[0]=0;S[x]=S[ch[x][0]]+S[ch[x][1]]+num[x];return;}
int gets(int x)
{
    return (ch[fa[x]][1]==x);
}
void rotate(int x)
{
    int F=fa[x];
    int d=gets(x);
    int GF=fa[F];
    int dd=gets(F);
    if(GF)
    ch[GF][dd]=x;
    ch[F][d]=ch[x][!d];
    fa[ch[x][!d]]=F;
    ch[x][!d]=F;
    fa[x]=GF;
    fa[F]=x;
    pushup(F);pushup(x);
    return;
}
void splay(int x,int ff)
{

    for(int F;(F=fa[x])!=ff;rotate(x))
    {
        if(fa[F])
        {
            if(!((gets(F))^(gets(x)))) rotate(F);
            else rotate(x);
        }
    }
    if(!ff) root=x;
}
int find(int dd)
{
    int r=root;
    while(val[r]!=dd)
    {
        if(dd<val[r])
        {
            if(!ch[r][0]) break;
            r=ch[r][0];
        }
        else
        {
            if(!ch[r][1]) break;
            r=ch[r][1];
        }
     } 
    return r;
}
void insert(int dd)
{

    int ll=find(dd);
    if(val[ll]!=dd)
    {
        val[++size]=dd;
        num[size]=0;
        fa[size]=ll;
        if(dd<val[ll]) ch[ll][0]=size;else ch[ll][1]=size;
        ch[size][0]=ch[size][1]=0;
        ll=size;
    }
    splay(ll,0);
    num[ll]++;
    pushup(ll);
}
int succ(int node)
{
    int r=ch[node][0];
    while(ch[r][1]) r=ch[r][1];
    return r;
}
int pred(int node)
{
    int r=ch[node][1];
    while(ch[r][0]) r=ch[r][0];
    return r;
}
void del(int x)
{
    int node=find(x);
    splay(node,0);
    num[node]--;
    if(num[node]==0)
    {
        if(!ch[node][0]&&!ch[node][1])root=0;
        else if(!ch[node][0])
        {
            root=ch[node][1];fa[ch[node][1]]=0;
        }
        else if(!ch[node][1])
        {
            root=ch[node][0];fa[ch[node][0]]=0;
        }
        else
        {
            int ll=succ(node);
            fa[ch[node][0]]=0;
            splay(ll,0);
            fa[ch[node][1]]=ll;
            ch[ll][1]=ch[node][1];
            pushup(ll);
        }
    }
}
int element(int k)
{
    int r=root;
    while(1)
    {
        if(S[ch[r][0]]<k&&S[ch[r][0]]+num[r]>=k) return r;
        if(S[ch[r][0]]>=k) r=ch[r][0];
        else if(S[ch[r][1]]) {k-=num[r]+S[ch[r][0]];r=ch[r][1];}
    }
}
int main()
{
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d%d",&opt,&it);
        if(opt==1){insert(it);}
        else if(opt==2){del(it);}
        else if(opt==3){int ll=find(it);splay(ll,0);printf("%d\n",S[ch[root][0]]+1);}
        else if(opt==4){int ll=element(it);printf("%d\n",val[ll]);splay(ll,0);}
        else if(opt==5){insert(it);printf("%d\n",val[succ(find(it))]);del(it);}
        else {insert(it);printf("%d\n",val[pred(find(it))]);del(it);}
    }
}

精简后的代码

#include<bits/stdc++.h>
using namespace std;
#define N 1000001
int num[N],S[N],key[N],fa[N],ch[N][2],val[N];int n,m;int opt,it,root,size=0;
void pushup(int x){S[0]=0;S[x]=S[ch[x][0]]+S[ch[x][1]]+num[x];return;}
int gets(int x){return (ch[fa[x]][1]==x);}
void rotate(int x)
{
    int F=fa[x];int d=gets(x);int GF=fa[F];int dd=gets(F);
    if(GF)
    ch[GF][dd]=x;
    ch[F][d]=ch[x][!d];
    fa[ch[x][!d]]=F;
    ch[x][!d]=F;
    fa[x]=GF;
    fa[F]=x;
    pushup(F);pushup(x);
    return;
}
void splay(int x,int ff)
{

    for(int F;(F=fa[x])!=ff;rotate(x))
    if(fa[F]){if(!((gets(F))^(gets(x)))) rotate(F);  else rotate(x);}
    if(!ff) root=x;
}
int find(int dd)
{
    int r=root;
    while(val[r]!=dd)
    {
        if(dd<val[r]){if(!ch[r][0]) break;r=ch[r][0];}
        else{if(!ch[r][1]) break;r=ch[r][1];}
    } 
    return r;
}
void insert(int dd)
{
    int ll=find(dd);
    if(val[ll]!=dd)
    {
        val[++size]=dd;
        fa[size]=ll;
        if(dd<val[ll]) ch[ll][0]=size;else ch[ll][1]=size;
        ll=size;
    }
    splay(ll,0);
    num[ll]++;
    pushup(ll);
}
int succ(int node)
{
    int r=ch[node][0];
    while(ch[r][1]) r=ch[r][1];
    return r;
}
int pred(int node)
{
    int r=ch[node][1];
    while(ch[r][0]) r=ch[r][0];
    return r;
}
void del(int x)
{
    int node=find(x);splay(node,0);num[node]--;
    if(num[node]==0)
    {
        if(!ch[node][0]&&!ch[node][1])root=0;
        else if(!ch[node][0]){root=ch[node][1];fa[ch[node][1]]=0;}
        else if(!ch[node][1]){root=ch[node][0];fa[ch[node][0]]=0;}
        else
        {
            int ll=succ(node);
            fa[ch[node][0]]=0;
            splay(ll,0);
            fa[ch[node][1]]=ll;
            ch[ll][1]=ch[node][1];
            pushup(ll);
        }
    }
}
int element(int k)
{
    int r=root;
    while(1)
    {
        if(S[ch[r][0]]<k&&S[ch[r][0]]+num[r]>=k) return r;
        if(S[ch[r][0]]>=k) r=ch[r][0];
        else if(S[ch[r][1]]) {k-=num[r]+S[ch[r][0]];r=ch[r][1];}
    }
}
int main()
{
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d%d",&opt,&it);
        if(opt==1){insert(it);}
        else if(opt==2){del(it);}
        else if(opt==3){int ll=find(it);splay(ll,0);printf("%d\n",S[ch[root][0]]+1);}
        else if(opt==4){int ll=element(it);printf("%d\n",val[ll]);splay(ll,0);}
        else if(opt==5){insert(it);printf("%d\n",val[succ(find(it))]);del(it);}
        else {insert(it);printf("%d\n",val[pred(find(it))]);del(it);}
    }
}
Timsei
关注
洛谷P2596 [ZJOI2006]书架（BZOJ1861）
forezxl的博客
12-03 1191
平衡树 洛谷题目传送门 BZOJ题目传送门 初始想法： 对于每个节点，新增一个变量表示当前节点的优先级，用Splay维护。 置顶/置底时先把节点取出，把优先级修改到最大/最小，再插入。 放回时把两个节点取出，交换优先级后插入。 询问的话直接做就好了。 然而打了一个下午没打出来。。。实在太烦了。。。 这时候ZZK飘了过来，看了一眼：“这不是平衡树维护序列裸题吗” Orz 正解：...
LCT（动态树）（洛谷P3690）（BZOJ3282）
forezxl的博客
01-07 523
推荐这篇论文 前置技能 Splay和树链剖分 简介 动态树问题, 简称LCT，近几年在OI中兴起的一种新型问题，是一类要求维护一个有根树森林，支持对树的分割, 合并等操作的问题。 算法用途 比如维护一个数据结构，有如下操作： 1.查询路径权值和。 2.查询LCA。 3.修改单个点的权值。 4.断开两个点，使之成为两棵树。 5.合并两个点，使之成为一颗树。 当然还...
[luogu3369] 普通平衡树（splay模板）
Tricksterism
06-14 90
[luogu3369] 普通平衡树（splay模板） 题目描述 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1.插入 xx 数 2.删除 xx 数(若有多个相同的数，因只删除一个) 3.查询 xx 数的排名(排名定义为比当前数小的数的个数 +1+1 。若有多个相同的数，因输出最小的排名) 4.查询排名为 xx 的数...
splay 模板 洛谷3369
weixin_30810583的博客
05-01 112
题目描述 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 插入 xx 数 删除 xx 数(若有多个相同的数，因只删除一个) 查询 xx 数的排名(排名定义为比当前数小的数的个数 +1+1 。若有多个相同的数，因输出最小的排名) 查询排名为 xx 的数 求 xx 的前驱(前驱定义为小于 xx ，且最大的数) ...
洛谷.3369.[模板]普通平衡树(Splay)
weixin_30516243的博客
02-09 134
题目链接 第一次写(2017.11.7)： #include<cstdio> #include<cctype> using namespace std; const int N=1e5+5,INF=1e9; int size,root,t[N],sz[N],son[N][2],fa[N],cnt[N]; inline int read() { int now=0...
洛谷 3369 普通平衡树 splay模板
iwi
04-01 323
题目：普通平衡树   参考： yyb大佬的代码 luogu大佬的题解   代码： #include&lt;bits/stdc++.h&gt; using namespace std; #define maxn 100000 #define inf (1&lt;&lt;30) struct Node { int val; int cnt; int fa,ch[2]; in...
无指针的Splay
不写博客
04-05 545
一个萌萌的Splay板子。 看到大部分大佬都是用指针来实现的Splay。小的只是按照Splay的核心思想和原理来进行的。那么这个东东存在的意义就是让不会敲Splay的人额。。。会敲Splay啦。。。
BZOJ3224 洛谷3369 Tyvj 1728 普通平衡树 splay
weixin_30527143的博客
11-21 115
欢迎访问~原文出处——博客园-zhouzhendong 去博客园看该题解 题目传送门 - BZOJ3224 题意概括 　　您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：1. 插入x数2. 删除x数(若有多个相同的数，因只删除一个)3. 查询x数的排名(若有多个相同的数，因输出最小的排名)4. 查询排名为x的数5. 求x的前驱(前驱定义为小于x，且最大的...
BZOJ3224/洛谷P3391 - 普通平衡树(Splay)
ayw1069的博客
11-30 121
BZOJ链接 洛谷链接 题意简述 模板题啦~ 代码 //普通平衡树(Splay) #include <cstdio> int const N=1e5+10; int rt,ndCnt; int ch[N][2],fa[N],val[N],siz[N]...
BZOJ1500: [NOI2005]维修数列（洛谷P2042）
forezxl的博客
12-09 344
Splay
bzoj4712: 洪水 动态Dp 树链剖分+线段树 或 LCT维护矩阵乘法
maxtir的博客
07-22 528
bzoj4712: 洪水 Description 小A走到一个山脚下，准备给自己造一个小屋。这时候，小A的朋友（op，又叫管理员）打开了创造模式，然后飞到 山顶放了格水。于是小A面前出现了一个瀑布。作为平民的小A只好老实巴交地爬山堵水。那么问题来了：我们把这 个瀑布看成是一个n个节点的树，每个节点有权值（爬上去的代价）。小A要选择一些节点，以其权值和作为代价将 这些点删除（堵上），使得根...
OI每周刷题记录——lrllrl
翻过这座山，他们就会听到你的故事
09-16 1718
看这标题就知道我是模仿的hzwer大佬，远程%%% 大佬的OI经历让蒟蒻我深受感触，为了晚一些AFO本蒟蒻也得加油了 从高二上期第一周开始计数，每个星期天更一次，一直更到我AFO 2018.9.2~2018.9.8 线段树： CH4301 线段树 poj2482（同洛谷P1502） 线段树+离散化+扫描线 CH4302 线段树+最大公约数+树状数组+构造 poj2481 线...
平衡树【Treap】
weixin_30466039的博客
07-09 122
平衡树的板题，用Treap实现。 具体参见注释，写的很详细了，包括了原理，实现以及注意事项 蒟蒻写个注释板子写了两天，太弱了QAQ 感谢niiick指导 Code #include<iostream> #include<cstdio> #include<queue> #include<cstring> #include<algorithm&gt...
洛谷P3369 普通平衡树(Treap/Splay)
Ab.Ever
04-17 1813
题目描述您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1. 插入x数 2. 删除x数(若有多个相同的数，因只删除一个) 3. 查询x数的排名(若有多个相同的数，因输出最小的排名) 4. 查询排名为x的数 5. 求x的前驱(前驱定义为小于x，且最大的数) 6. 求x的后继(后继定义为大于x，且最小的数)输入输出格式输入格式：第一行为n，表示操作的个数,
基于大模型技术的算力产业监测服务平台设计
09-17
内容概要：本文提出了一种新型算力产业监测服务平台的设计理念，运用国内自主研发的大模型技术支持，通过对传统技术的改进和完善，提出了三层架构的设计方法，即基础设施层（含向量数据库和模型训练）、大模型应用框架层（强化数据处理与多维关系挖掘）及业务层（如智能分析助手）。这种设计方案旨在提高算力产业发展监测与决策制定的质量。 适合人群：电信行业的从业人员及研究人员；算力产业链各环节管理者；政府相关机构和政策决策者。 使用场景及目标：在多种算力相关的应用场景（如云计算中心管理，数据中心监测，政策分析）中辅助决策者进行快速有效的信息获取和技术选择；助力算力产业发展方向的精确把控和战略调整。 其他说明：随着大模型技术的日臻成熟，该算力产业监测服务平台预计将进一步丰富自身的应用领域和服务深度，以促进算力行业更智慧化发展。
This_honeypot_supports_Telnet_and_SSH_two_protocol_FF-Pot.zip
最新发布
09-17
This_honeypot_supports_Telnet_and_SSH_two_protocol_FF-Pot
吉他谱_What I've Done - Linkin Park.pdf
09-17
初级入门吉他谱 guitar tab
吉他谱_Too sweet - Hozier.pdf
09-17
初级入门吉他谱 guitar tab
洛谷 P1640 BZOJ 1854 [SCOI2010]连续攻击游戏
05-14
这道题目需要进行博弈论的思考。我们可以使用动态规划来解决这道题目。 首先，我们可以定义 $f_{i,j}$ 表示当前剩下 $i$ 到 $j$ 这些数时，当前玩家最多能获得的分数。我们可以发现，在这个状态中，当前玩家只能从 $i$ 或者 $j$ 中选择一个数进行取走，然后将剩下的部分转化为对手的状态。因此，我们可以得到如下的转移方程： $$ f_{i,j}=\max\{a_i+\min\{f_{i+2,j},f_{i+1,j-1}\},a_j+\min\{f_{i+1,j-1},f_{i,j-2}\}\} $$ 其中 $a_i$ 表示第 $i$ 个数的分值。上述方程的含义是，当前玩家可以选择取走 $i$ 或者 $j$，如果取走 $i$，则转化为对手的状态是 $f_{i+2,j}$ 或者 $f_{i+1,j-1}$，如果取走 $j$，则转化为对手的状态是 $f_{i,j-2}$ 或者 $f_{i+1,j-1}$。当前玩家希望获得的分数是最大的，因此需要取两种情况中的较大值。 最终答案就是 $f_{1,n}$，表示从 $1$ 到 $n$ 这些数中，当前玩家最多能获得的分数。 最后，需要注意的是，我们需要使用逆序的方式来进行动态规划，即从小到大枚举区间长度 $len$，然后枚举区间起点 $i$，最终计算 $f_{1,n}$。这样可以保证在计算 $f_{i,j}$ 时，$f_{i+1,j}$ 和 $f_{i,j-1}$ 已经被计算出来了。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值