[rope大法好] STL里面的可持久化平衡树--rope

简单用法:

#include <ext/rope>
using namespace __gnu_cxx;
int a[1000];
rope<int> x;
rope<int> x(a,a + n);
rope<int> a(x);

x->at(10);
x[10];
x->push_back(x)     // 在末尾添加x
x->insert(pos,x)    // 在pos插入x
x->erase(pos,x)     // 从pos开始删除x个
x->replace(pos,x)   // 从pos开始换成x
x->substr(pos,x)    // 提取pos开始x个

 

例题一:

IOI2012

scrivener

题意

设计支持如下 3 种操作:

1.T x:在文章末尾打下一个小写字母 x。(type 操作) 
2.U x:撤销最后的x 次修改操作。(Undo 操作)

(注意Query 操作并不算修改操作)

3.Q x:询问当前文章中第x 个字母并输出。(Query 操作)

操作数n<=100000 在线算法

clj都说这是道rope傻逼题……

 

#include<cstdio>
#include<cstring>
#include<cctype>
#include<iostream>
#include<algorithm>
#include<ext/rope>
using namespace std;
using namespace __gnu_cxx;
const int maxn=1e5+10;
rope<char> *his[maxn];
int n;
int d[maxn];
inline int lowbit(int x){ return x&-x; }

inline void updata(int x){ while(x<=n){ d[x]++; x+=lowbit(x); } }
inline int get(int x){ int res=0; while(x){ res+=d[x]; x-=lowbit(x); }return res; }

inline char getC(){ char ch=getchar(); while(!isalpha(ch))ch=getchar(); return ch; }

inline int getint()
{
    int res=0; char ch,ok=0;
    while(ch=getchar())
    {
        if(isdigit(ch)){ res*=10;res+=ch-‘0‘;ok=1; }
        else if(ok)break;
    }
    return res;
}
void deb(rope<char> s)
{
    for(int i=0;i<s.length();i++)
        cout<<s[i];puts("");
}

int main()
{
//    freopen("type.in","r",stdin);
//    freopen("type.out","w",stdout);
    n=getint();
    his[0]=new rope<char>();
    for(int i=1;i<=n;i++)
    {
        his[i]=new rope<char>(*his[i-1]);
        // deb(*his[i]);
        char opt=getC();
        if(opt==‘T‘)
        {
            char x=getC();
            his[i]->push_back(x);
            updata(i);
        }
        else if(opt==‘U‘)
        {
            updata(i);
            int x=getint();
            int l=1,r=i,mid,now=get(i);
            while(l<r)
            {
                mid=(l+r)>>1;
                if(now-get(mid)>x) l=mid+1;
                else r=mid;
            }
            his[i]=his[l-1];
        }
        else if(opt==‘Q‘)
        {
            int x=getint()-1;
            putchar(his[i]->at(x));
            putchar(‘\n‘);
        } // deb(*his[i]);
    }
    return 0;
}

 

其中,实现可持久化的操作是:his[i]=new rope<char>(*his[i-1]);

他可以实现O(1)的copy历史版本,因为rope的底层是红黑树,所以copy时只需copy根指针。

一键持久化……

 

例题二:

BZOJ 3673: 可持久化并查集 by zky

n个集合 m个操作

操作:

1 a b 合并a,b所在集合

2 k 回到第k次操作之后的状态(查询算作操作)

3 a b 询问a,b是否属于同一集合,是则输出1否则输出0

0<n,m<=2*10^4

分析:直接可持久化并查集的fa数组就可以了。

ACCode:

#include <cstdio>
#include <ext/rope>
using namespace std;
using namespace __gnu_cxx;

const int maxm = 20010;

rope<int> *rp[maxm];

int find(int i,int x)
{
    if(rp[i]->at(x) == x)   return x;
    int f = find(i,rp[i]->at(x));
    if(f == rp[i]->at(x))   return f;
    rp[i]->replace(x,f);
    return rp[i]->at(x);
}

inline void merge(int i,int x,int y)
{
    x = find(i,x),y = find(i,y);
    if(x != y)  rp[i]->replace(y,x);
}

int a[maxm],lastans;

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= n;i ++)  a[i] = i;
    rp[0] = new rope<int> (a,a + n + 1);
    for(int i = 1;i <= m;i ++)
    {
        rp[i] = new rope<int> (*rp[i - 1]);
        int opt;    scanf("%d",&opt);
        if(opt == 1)
        {
            int a,b;    scanf("%d%d",&a,&b);
            merge(i,a/* ^ lastans*/,b/* ^ lastans*/);
        }
        else if(opt == 2)
        {
            int k;  scanf("%d",&k);
            rp[i] = rp[k/* ^ lastans*/];
        }
        else
        {
            int a,b;    scanf("%d%d",&a,&b);
            printf("%d\n",lastans = (find(i,a/* ^ lastans*/) == find(i,b/* ^ lastans*/)));
        }
    }
    return 0;
}

 

例题三:

AHOI2006文本编辑器editor

题意

设计数据结构支持

插入删除反转字符串

分析:

由于rope的底层实现,insert,erase,get都是logn的

就是翻转不行,不是自己手写的打不了标记啊!!

怎么办?

答:同时维护一正一反两个rope……反转即交换两个子串……Orz……

区间循环位移?简单,拆成多个子串连起来就好了……

区间a变b b变c c变d …… z变a? 呃……维护26个rope?

区间和?滚蛋,那是线段树的活

区间kth?sorry,与数值有关的操作rope一概不支持……

5555 维修数列只能自己写了……

ACCode:

#include <cstdio>
#include <ext/rope>
#include <iostream>
#include <algorithm>
using namespace std;
using namespace __gnu_cxx;
crope a,b,tmp;
char s[10];
int now,n,len,size;
char str[2000000],rstr[2000000];
int main()
{
    scanf("%d",&n);
    while(n--)
    {
        scanf("%s",s);
        switch(s[0])
        {
            case ‘M‘:
            {
                scanf("%d",&now);
                break;
            }
            case ‘P‘:
            {
                now--;
                break;
            }
            case ‘N‘:
            {
                now++;
                break;
            }
            case ‘G‘:
            {
                putchar(a[now]);
                putchar(‘\n‘);
                break;
            }
            case ‘I‘:
            {
                scanf("%d",&size);
                len=a.length();
                for(int i=0;i<size;i++)
                {
                    do
                    {
                        str[i]=getchar();
                    }
                    while(str[i]==‘\n‘);
                    rstr[size-i-1]=str[i];
                }
                rstr[size]=str[size]=‘\0‘;
                a.insert(now,str);
                b.insert(len-now,rstr);
                break;
            }
            case ‘D‘:
            {
                scanf("%d",&size);
                len=a.length();
                a.erase(now,size);
                b.erase(len-now-size,size);
                break;
            }
            case ‘R‘:
            {
                scanf("%d",&size);
                len=a.length();
                tmp=a.substr(now,size);
                a=a.substr(0,now) + b.substr(len-now-size,size) + a.substr(now+size,len-now-size);
                b=b.substr(0,len-now-size)+tmp+b.substr(len-now,now);
                break;
            }
        }
    }
    return 0;
}

 

 

END

[rope大法好] STL里面的可持久化平衡树--rope,布布扣,bubuko.com

时间: 2024-10-11 12:26:45

[rope大法好] STL里面的可持久化平衡树--rope的相关文章

C++ STL rope 可持久化平衡树 (可持久化数组)

官方文档好像 GG 了. rope 不属于标准 STL,属于扩展 STL,来自 pb_ds 库 (Policy-Based Data Structures). 基本操作: #include <ext/rope> // 头文件 using namespace __gnu_cxx; // 注意名称空间 rope<int> rp; int main() { rp.push_back(x); // 在末尾插入 x rp.insert(pos, x); // 在 pos 处插入 x rp.e

洛谷P3835 【模板】可持久化平衡树

题目背景 本题为题目 普通平衡树 的可持久化加强版. 数据已经经过强化 题目描述 您需要写一种数据结构(可参考题目标题),来维护一些数,其中需要提供以下操作(对于各个以往的历史版本): 插入x数 删除x数(若有多个相同的数,因只删除一个,如果没有请忽略该操作) 查询x数的排名(排名定义为比当前数小的数的个数+1.若有多个相同的数,因输出最小的排名) 查询排名为x的数 求x的前驱(前驱定义为小于x,且最大的数,如不存在输出-2147483647) 求x的后继(后继定义为大于x,且最小的数,如不存在

Luogu P3835 【模板】可持久化平衡树

P3835 [模板]可持久化平衡树 题意 题目背景 本题为题目普通平衡树的可持久化加强版. 题目描述 您需要写一种数据结构(可参考题目标题),来维护一些数,其中需要提供以下操作(对于各个以往的历史版本): 插入\(x\)数 删除\(x\)数(若有多个相同的数,因只删除一个,如果没有请忽略该操作) 查询\(x\)数的排名(排名定义为比当前数小的数的个数\(+1\).若有多个相同的数,因输出最小的排名) 查询排名为x的数 求\(x\)的前驱(前驱定义为小于\(x\),且最大的数,如不存在输出\(-2

【模板】可持久化平衡树

题目背景 本题为题目 普通平衡树 的可持久化加强版. 数据已经经过强化 感谢@Kelin 提供的一组hack数据 题目描述 您需要写一种数据结构(可参考题目标题),来维护一些数,其中需要提供以下操作(对于各个以往的历史版本): 插入x数 删除x数(若有多个相同的数,因只删除一个,如果没有请忽略该操作) 查询x数的排名(排名定义为比当前数小的数的个数+1.若有多个相同的数,因输出最小的排名) 查询排名为x的数 求x的前驱(前驱定义为小于x,且最大的数,如不存在输出-2147483647) 求x的后

可持久化平衡树详解及实现方法分析

目录 前置要求 核心思想 实现方法比较:指针 与 数组模拟指针 Merge 是否应该新建节点 参考程序 前置要求 带旋转的平衡树会改变祖先关系,这令可持久化变得困难.所以需要使用非旋的平衡树,如非旋treap.本文以非旋treap为例. 核心思想 可持久化的数据结构,其核心都是不改变历史的信息.当需要对信息进行修改的时候就新开一个节点,继承历史信息,然后再进行修改. 对于非旋treap来说,主要是对 Split 和 Merge 两个操作进行可持久化.剩下的操作不会对数据产生影响.而考虑到非旋tr

Codevs1860最大数string大法好,STL万岁。。

刀是九长九短十八般兵器中公认的九短之首习剑的比较聪明懒得争什么九短之首直接 ┘渔芑削 痨蝽糁匾 忖⒇敉 僻线≡ 泔魔 厚港婀 占氨碳壳偻盎腺慌怕讲拾矩炎抗墜 要是现在不当这个狗屁倒灶的陵州刺史幽凉两州更不可能以后怎么能以最快速度当上北 从无兑水的习惯绿蚁有好坏但都地地道道.随着中原江湖人蜂拥赶赴武当山也不知是 中就又是一枪砸向韩貂寺脖颈韩貂寺冷哼一声虽然才两招显然人猫就已经腻歪了这名 仂朔ⅸ肢 蜷肾健 ョ罢镫迕 "历尽千辛万苦才得以总领天下道教事务现在丢了一半江山广陵江以北都划给了

[luogu3835]可持久化平衡树

就是把普通平衡树的代码可持久化一下 第一发90,最后两个点MLE???这是什么操作 后来把能非递归的都改成非递归,结果TLE???这又是什么操作 最后发现我才用了内存限制的一半,改大一点之后过掉倒数第二个点,再改大一点就A掉了 所以TLE是什么鬼啊 之前立了个用指针的flag,结果这题指针版会MLE...... #include<stdio.h> #include<stdlib.h> #include<time.h> int l[25000000],r[25000000

洛谷 P3835 【模板】可持久化平衡树

这个题也是可以用可持久化线段树来解决的. 值域线段树(也有的叫权值线段树)可以用来维护一个可重集,并实现一些一般情况下平衡树才能实现的事情. 如果用值来当做区间左右端点,每个叶子节点上存某个值出现的次数,非叶子节点上存一定范围内的值出现的总次数,就可以建成值域线段树.可以在上面直接查询第k大值.小于某值的数的个数等等,具体请百度或参见代码. 如何将线段树可持久化呢?线段树在单点更新的时候会经过log n个节点,每一次更新时显然也只有这么多节点会发生变化. 记录每一个版本的线段树的根节点,每一次操

可持久化平衡树

可持久化普通平衡树 题意 如题. 解法 大家都知道,用权值线段树可以过普通平衡树那道题,那么对于可持久化普通平衡树,我们是否也可以用主席树来搞一搞呢.答案是肯定的.只需要动态开点就行了.其他的跟普通平衡树那道题一模一样. 代码 这里需要注意一点,当 l 和 r 都是负数的时候, /2 就会有问题,因为 $ -5/2 = -2$ 而 $ -5 >> 1 = -3$ ,所以除2会使 l 一直小于mid,从而陷入死循环. #include <bits/stdc++.h> #define