BZOJ3224 普通平衡树

最新推荐文章于 2019-07-26 23:06:59 发布
原创 最新推荐文章于 2019-07-26 23:06:59 发布 · 468 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#后缀数组 #字符串 #模板 #uoj

本文介绍了一种名为普通平衡树的数据结构，该结构可以高效地进行插入、删除、查询等操作。文章提供了Splay、Treap和替罪羊树三种实现方式的代码示例，并详细解释了每种方法的特点。

BZOJ3224: Tyvj 1728 普通平衡树
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]

写了Splay、Treap和替罪羊树。然而并不觉得后面两个好写或者比Splay快啊。

Splay：

#include <bits/stdc++.h>
#define N 100010
#define INF 10000010
#define mid ((l+r)>>1)
#define Lc cur->ch[0]
#define Rc cur->ch[1]
#define rep(i,l,r) for (int i=l;i<=r;i++)
using namespace std;
int n;
struct node{
    int x,num,size;
    node *ch[2],*fa;
}t[N],*root,*tail=t;

template <class Aqua>
inline void read(Aqua &s){
    s=0; Aqua f=1; char c=getchar();
    while (!isdigit(c)) {if (c=='-') f=-1; c=getchar();}
    while (isdigit(c)) s=s*10+c-'0',c=getchar();
    s*=f;
}

inline node *newnode(int x,int d){
    node *cur=++tail;
    cur->x=x; cur->num=cur->size=d;
    cur->ch[0]=cur->ch[1]=cur->fa=t;
    return cur;
}

void pre(){
    root=newnode(-INF,1);
    root->ch[1]=newnode(INF,1);
    root->ch[1]->fa=root;
    root->size=2;
    t->x=t->num=t->size=0;
    t->ch[0]=t->ch[1]=t->fa=t;
}

inline node *Min(node *a,node *b){
    return (a->x<b->x)?a:b;
}

inline node *Max(node *a,node *b){
    return (a->x<b->x)?b:a;
}

inline int get(node *cur){
    return (cur->fa->ch[0]==cur)?0:1;
}

inline void update(node *cur){
    cur->size=Lc->size+Rc->size+cur->num;
}

void rotate(node *cur){
    node *fa=cur->fa; int x=get(cur);
    cur->fa=fa->fa; fa->fa->ch[get(fa)]=cur;
    fa->fa=cur; fa->ch[x]=cur->ch[x^1];
    fa->ch[x]->fa=fa; cur->ch[x^1]=fa;
    update(fa),update(cur);
}

void splay(node *cur,node *&to){
    for (node *end=to->fa;cur->fa!=end;rotate(cur))
        if (cur->fa->fa!=end)
            rotate((get(cur)^get(cur->fa))?cur:cur->fa);
    to=cur;
}

void insert(int x){
    node *fa,*cur;
    for (cur=root;cur!=t;cur=(cur->x>x)?Lc:Rc){
        cur->size++; fa=cur;
        if (cur->x==x){
            cur->num++; break;
        }
    }
    if (cur==t){
        cur=newnode(x,1); cur->fa=fa;
        fa->ch[(x<fa->x)?0:1]=cur;
    }
    splay(cur,root);
}

node *find(node *cur,int x){
    return (cur->x==x)?cur:((cur->x>x)?find(Lc,x):find(Rc,x));
}

int qrank(node *cur){
    splay(cur,root);
    return Lc->size+1;
}

node *select(node *cur,int k){
    return (k<=Lc->size)?select(Lc,k):((k<=Lc->size+cur->num)?cur:select(Rc,k-Lc->size-cur->num));
}

node *pre(node *cur,int x){
    return (cur==t)?t+1:((cur->x>=x)?pre(Lc,x):Max(cur,pre(Rc,x)));
}

node *nxt(node *cur,int x){
    return (cur==t)?t+2:((cur->x<=x)?nxt(Rc,x):Min(cur,nxt(Lc,x)));
}

int main(){
    read(n);
    pre();
    int opt,x; node *tmp;
    rep(i,1,n){
        read(opt),read(x);
        if (opt==1)
            insert(x);
        if (opt==2){
            tmp=find(root,x);
            if (tmp->num!=1)
                tmp->num--,splay(tmp,root);
            else{
                splay(pre(root,x),root);
                splay(nxt(root,x),root->ch[1]);
                root->ch[1]->ch[0]=t;
                update(root->ch[1]),update(root);
            }
        }
        if (opt==3){
            printf("%d\n",qrank(tmp=find(root,x))-1);
            splay(tmp,root);
        }
        if (opt==4){
            printf("%d\n",(tmp=select(root,x+1))->x);
            splay(tmp,root);
        }
        if (opt==5){
            printf("%d\n",(tmp=pre(root,x))->x);
            splay(tmp,root);
        }
        if (opt==6){
            printf("%d\n",(tmp=nxt(root,x))->x);
            splay(tmp,root);
        }
    }
    return 0;
}

Treap：

#include <bits/stdc++.h>
#define N 100010
#define INF INT_MAX
using namespace std;
int n;
struct tree{
    tree *ch[2],*fa;
    int p,v,size;
}t[N],*tail=t,*root=t;

template <class Aqua>
inline void read(Aqua &s){
    s=0; Aqua f=1; char c=getchar();
    while (!isdigit(c)) {if (c=='-') f=-1; c=getchar();}
    while (isdigit(c)) s=s*10+c-'0',c=getchar();
    s*=f;
}

inline int getfa(tree *cur){
    return (cur->fa->ch[0]==cur?0:1);
}

inline void update(tree *cur){
    cur->size=cur->ch[0]->size+cur->ch[1]->size+1;
}

inline void rotate(tree *cur){
    int x=getfa(cur); tree *fa=cur->fa;
    fa->fa->ch[getfa(fa)]=cur;
    cur->fa=fa->fa;
    cur->ch[x^1]->fa=fa;
    fa->ch[x]=cur->ch[x^1];
    fa->fa=cur;
    cur->ch[x^1]=fa;
    update(fa); update(cur);
}

tree *insert(tree *cur,int d,int p,tree *fa){
    if (cur==t){
        cur=++tail; cur->size=1;
        cur->v=d; cur->p=p;
        cur->fa=fa;
        cur->ch[0]=cur->ch[1]=t;
        fa->ch[d<fa->v?0:1]=cur;
        return cur;
    }
    int x=d<cur->v?0:1;
    cur->ch[x]=insert(cur->ch[x],d,p,cur);
    if (cur->ch[x]->p<cur->p)
        rotate(cur=cur->ch[x]);
    update(cur);
    return cur;
}

tree *del(tree *cur,int d){
    if (cur->v==d){
        if (cur->size==1)
            return t;
        else{
            int x=cur->ch[0]->p<=cur->ch[1]->p?0:1;
            rotate(cur=cur->ch[x]);
            cur->ch[x^1]=del(cur->ch[x^1],d);
            update(cur);
            return cur;
        }
    }
    int x=d<cur->v?0:1;
    cur->ch[x]=del(cur->ch[x],d);
    update(cur);
    return cur;
}

int getrank(tree *cur,int d){
    return (cur==t?1:(cur->v>=d?getrank(cur->ch[0],d):cur->ch[0]->size+1+getrank(cur->ch[1],d)));
}

tree *select(tree *cur,int d){
    return (d<=cur->ch[0]->size?select(cur->ch[0],d):(d>cur->ch[0]->size+1?select(cur->ch[1],d-cur->ch[0]->size-1):cur));
}

int main(){
    srand(20010823);
    read(n);
    int op,x;
    root=insert(root,-INF,rand(),t);
    root=insert(root,INF,rand(),t);
    t->size=0; t->p=INF;
    for (int i=1;i<=n;i++){
        read(op),read(x);
        if (op==1)
            root=insert(root,x,rand(),t);
        if (op==2)
            root=del(root,x);
        if (op==3)
            printf("%d\n",getrank(root,x)-1);
        if (op==4)
            printf("%d\n",select(root,x+1)->v);
        if (op==5)
            printf("%d\n",select(root,getrank(root,x)-1)->v);
        if (op==6)
            printf("%d\n",select(root,getrank(root,x+1))->v);
    }
    return 0;
}

Scapegoat Tree：

#include <bits/stdc++.h>
#define N 100010
#define INF 2000000010
#define alpha 0.65
using namespace std;
int n,cnt;
struct tree{
    tree *fa,*ch[2];
    int size,num,x;
}t[N],*q[N],*root=t+1,*node=t,*tail=t+2;

template <class Aqua>
inline void read(Aqua &s){
    s=0; Aqua f=1; char c=getchar();
    while (!isdigit(c)) {if (c=='-') f=-1; c=getchar();}
    while (isdigit(c)) s=s*10+c-'0',c=getchar();
    s*=f;
}

void pre(){
    root->x=-INF; (t+2)->x=INF;
    root->ch[1]=t+2; (t+2)->fa=root;
    root->ch[0]=root->fa=(t+2)->ch[0]=(t+2)->ch[1]=t;
    (t+2)->size=root->num=(t+2)->num=1; root->size=2;
}

inline tree *newnode(int x){
    (++tail)->x=x;
    tail->size=tail->num=1;
    tail->ch[0]=tail->ch[1]=t;
    return tail;
}

inline bool check(tree *cur){
    return (max(cur->ch[0]->size,cur->ch[1]->size)>=(double)cur->size*alpha);
}

void ins(tree *cur,int x){
    cur->size++;
    if (cur->x==x && !cur->num){
        cur->num++;
        return;
    }
    int k=(x<cur->x?0:1);
    if (cur->ch[k]==t){
        cur->ch[k]=newnode(x);
        cur->ch[k]->fa=cur; 
    }
    else
        ins(cur->ch[k],x);
    if (check(cur)) node=cur;
}

void del(tree *cur,int x){
    cur->size--;
    if (cur->num && cur->ch[0]->size+1==x){
        cur->num--;
        if (check(cur)) node=cur;
        return;
    }
    if (cur->ch[0]->size+cur->num>=x)
        del(cur->ch[0],x);
    else
        del(cur->ch[1],x-cur->ch[0]->size-cur->num);
    if (check(cur)) node=cur;
}

int rank(tree *cur,int x){
    return (cur==t?1:(cur->x>=x?rank(cur->ch[0],x):rank(cur->ch[1],x)+cur->ch[0]->size+cur->num));
}

int select(tree *cur,int x){
    return (cur->ch[0]->size>=x?select(cur->ch[0],x):(cur->ch[0]->size+cur->num<x?select(cur->ch[1],x-cur->ch[0]->size-cur->num):cur->x));
}

void dfs(tree *cur){
    if (cur==t) return;
    dfs(cur->ch[0]);
    if (cur->num)
        q[++cnt]=cur;
    dfs(cur->ch[1]);
}

void build(tree *&cur,int l,int r,tree *fa){
    if (l>r){
        cur=t; return;
    }
    int mid=l+r>>1;
    cur=q[mid];
    cur->fa=fa;
    build(cur->ch[0],l,mid-1,cur);
    build(cur->ch[1],mid+1,r,cur);
    cur->size=cur->ch[0]->size+cur->ch[1]->size+1;
}

void rebuild(tree *cur,int x){
    cnt=0; dfs(cur);
    tree *fa=cur->fa;
    build((fa==t?root:(fa->ch[0]==cur?fa->ch[0]:fa->ch[1])),1,cnt,fa);
}

int main(){
    read(n);
    pre();
    int opt,x;
    for (int i=1;i<=n;node=t,i++){
        read(opt),read(x);
        if (opt==1)
            ins(root,x);
        if (opt==2)
            del(root,rank(root,x));
        if (opt==3)
            printf("%d\n",rank(root,x)-1);
        if (opt==4)
            printf("%d\n",select(root,x+1));
        if (opt==5)
            printf("%d\n",select(root,rank(root,x)-1));
        if (opt==6)
            printf("%d\n",select(root,rank(root,x+1)));
        if (node!=t)
            rebuild(node,i);
    }
    return 0;
}
（vector通过）bzoj3224: Tyvj 1728 普通平衡树
.
08-18 1万+
3224: Tyvj 1728 普通平衡树 Time Limit:10 SecMemory Limit:128 MB Submit:15204Solved:6614 [Submit][Status][Discuss] Description 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1. 插入x数 2. 删除x数(若有多个相同的
红黑树接口(pb_ds)水过普通平衡树BZOJ-3224
weixin_43533544的博客
06-03 1058
最近学平衡树，偶然发现了pbds这个库，里面有很多封装的很复杂的数据结构，各种平衡树，可并堆等。这篇文章主要讲一讲，平衡树套pb_ds这个模板的问题 首先，我们要 include 一下我们的主角 #include<bits/stdc++.h> #include<bits/extc++.h> using namespace std; using namespace __g...
bzoj 3224（平衡树）
Chen.Jr的博客
03-21 259
传送门 题意： 请你完成666种最基础的平衡树的操作。 题目分析： 什么也别说了，平衡树的板子题。收获到了一个写起来比较舒服的平衡树的板子。 代码： #include <bits/stdc++.h> using namespace std; const int maxn=200005; int ch[maxn][2],par[maxn],val[maxn],cnt[maxn],siz...
BZOJ3224:普通平衡树(含SBT、Treap、Splay模板)
weixin_34024034的博客
11-22 171
传送门 这道题就是裸的平衡树的题目，操作都是模板，也就不多说了，重在代码。 SBT: #include<cstdio> struct SBT { int v, sz, ch[2], cnt; } t[300005]; int n, cnt, root; #define Upd(k) {\ t[k].sz = t[t[k].ch[0]].sz...
bzoj3224
weixin_34080903的博客
11-07 204
平衡树模板在此！写了treap（话说好久没写splay了）注意对相同元素的处理 UPD：其实这里处理的不好，每个点可以代表一个元素值，然后记录出现次数即可，不用新添一个点 1 const rd=200007; 2 var fa,key,a,count:array[0..200010] of longint; 3 son:array[0..200010,1..2]...
【BZOJ3224】【TYVJ1728】普通平衡树
cz_xuyixuan的博客
01-14 739
【题目链接】 点击打开链接 【思路要点】 本题包含了平衡树最基本的操作。是任何学习平衡树都应当先做一遍的题。笔者实现了四种平衡树，Splay、Treap、替罪羊树和非旋转式Treap（以及其可持久化）。 【代码】 Splay/*Splay Tree Version*/ #include using namespace std;
平衡树--替罪羊树 *
Dream_maker的博客
06-03 496
平衡树之替罪羊树 –yangkai 身为平衡树却不做任何形式的旋转，替罪羊树可以称得上是最暴力的平衡树了。 替罪羊树(SGT)保留有二叉搜索树的基本性质，即对于任意一个节点t，左儿子的所有节点比它小，右儿子的所有节点比它大。但是既然不基于翻转，它怎样维护平衡树的优秀复杂度呢？ SDT基于一个叫做“重构”的操作，听起来很是优美暴力，那么我们要如何重构？ 首先，如果要时刻维持平衡树的平...
二逼平衡树（树套树）
KirinBill's blog(优快云)
06-19 1131
二逼平衡树（树套树） BZOJ-3196
bzoj 3224: Tyvj 1728 普通平衡树
lqybzx的专栏
11-05 754
Description 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1. 插入x数 2. 删除x数(若有多个相同的数，因只删除一个) 3. 查询x数的排名(若有多个相同的数，因输出最小的排名) 4. 查询排名为x的数 5. 求x的前驱(前驱定义为小于x，且最大的数) 6. 求x的后继(后继定义为大于x，且最小的数) Input 第
bzoj3224(普通平衡树 splay板子)
qq_42576687的博客
07-26 206
题目 splay #include<cstdio> #include<iostream> using namespace std; const int N=1e5+5; int ch[N][2],f[N],sz[N],cnt[N],val[N]; int tot,root; inline void _clear(int x){ ch[x][0]=ch[x][1]=...
bzoj 3224 普通平衡树(fhqtreap)
Timeclimber
07-27 513
3224: Tyvj 1728 普通平衡树 Time Limit: 10 Sec  Memory Limit: 128 MB Submit: 21374  Solved: 9545 [Submit][Status][Discuss] Description 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1. 插入x数 2. 删除x数(若有多个相同的数，因只删除...
BZOJ 3224 普通平衡树
我是谁 --- 卡比兽
09-26 230
BZOJ 3224 懒羊羊看了下BST treap  然后对着敲一下BZOJ 3224 代码有注释 额 感觉treap好玄学啊 rand是什么鬼 #include &lt;cstdio&gt; #include &lt;iostream&gt; #include &lt;queue&gt; #include &lt;cmath&gt; #include &lt;cstring&gt; #...
bzoj3224（treap）
cq_phqg
09-02 1178
3224: Tyvj 1728 普通平衡树 Time Limit: 10 Sec  Memory Limit: 128 MB Submit: 1844  Solved: 727 [Submit][Status] Description 您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作： 1. 插入x数 2. 删除x数(若有多个相同的数，因只删除一个)
[bzoj 3224] Tyvj 1728 普通平衡树（Splay）
chrt's blog
01-08 822
题意：维护一些数，支持这些操作：插入x、删除x、查询x的排名（多个x则输出最小者）、查询排名为x的数、查询小于x的最大数、查询大于x的最小数。初始序列为空，操作数不超过10^5，每个数的数据范围：[-1e7,1e7]。 写一棵普通的平衡树就好了。由于是想练习一下Splay Tree，就决定是它了。
【bzoj3224】普通平衡树 平衡树
chty_syq的博客
12-23 505
AC通道：http://www.lydsy.com/JudgeOnline/problem.php?id=3224 借此题来练习平衡树的模板。（以下数据均为bzoj亲测数据） 【Treap】 Memory：3762kb Time：248ms   #include #include #include #include #include #include #include using nam
bzoj3224（平衡树板子）
a1035719430的博客
07-20 244
裸的平衡树 写的是treap #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; int n , root , tot; const int INF = 0x7fffffff; struct tree{ int val , dat; int cnt , size; int l , r; }a[101000]; i...
bzoj 1040 zjoi2008 骑士 树形dp
08-08
题目描述 有一个 $n$ 个点的棋盘，每个点上有一个数字 $a_i$，你需要从 $(1,1)$ 走到 $(n,n)$，每次只能往右或往下走，每个格子只能经过一次，路径上的数字和为 $S$。定义一个点 $(x,y)$ 的权值为 $a_x+a_y$，求所有满足条件的路径中，所有点的权值和的最小值。 输入格式 第一行一个整数 $n$。 接下来 $n$ 行，每行 $n$ 个整数，表示棋盘上每个点的数字。 输出格式 输出一个整数，表示所有满足条件的路径中，所有点的权值和的最小值。 数据范围 $1\leq n\leq 300$ 输入样例 3 1 2 3 4 5 6 7 8 9 输出样例 25 算法1 (树形dp) $O(n^3)$ 我们可以先将所有点的权值求出来，然后将其看作是一个有权值的图，问题就转化为了在这个图中求从 $(1,1)$ 到 $(n,n)$ 的所有路径中，所有点的权值和的最小值。 我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子都被遍历过了，那么我们就可以计算出从它的左儿子到它的右儿子的路径中，所有点的权值和的最小值，然后再将这个值加上当前节点的权值，就可以得到从根节点到当前节点的路径中，所有点的权值和的最小值。 时间复杂度 树形dp的时间复杂度是 $O(n^3)$。 C++ 代码 算法2 (动态规划) $O(n^3)$ 我们可以使用动态规划来解决这个问题，具体来说，我们可以定义 $f(i,j,s)$ 表示从 $(1,1)$ 到 $(i,j)$ 的所有路径中，所有点的权值和为 $s$ 的最小值，那么我们就可以得到如下的状态转移方程： $$ f(i,j,s)=\min\{f(i-1,j,s-a_{i,j}),f(i,j-1,s-a_{i,j})\} $$ 其中 $a_{i,j}$ 表示点 $(i,j)$ 的权值。 时间复杂度 动态规划的时间复杂度是 $O(n^3)$。 C++ 代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值