LG5055 【模板】可持久化文艺平衡树

题意

您需要写一种数据结构，来维护一个序列，其中需要提供以下操作（对于各个以往的历史版本）：

1. 在第 pp 个数后插入数 xx 。
2. 删除第 pp 个数。
3. 翻转区间 [l,r][l,r]，例如原序列是 {5,4,3,2,1}{5,4,3,2,1}，翻转区间 [2,4][2,4] 后，结果是 {5,2,3,4,1}{5,2,3,4,1}。
4. 查询区间 [l,r][l,r] 中所有数的和。

和原本平衡树不同的一点是，每一次的任何操作都是基于某一个历史版本，同时生成一个新的版本（操作 44 即保持原版本无变化），新版本即编号为此次操作的序号。

本题强制在线。

分析

函数式Treap实现。

时空复杂度\(O(n \log n)\)

代码

// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<algorithm>
#include<bitset>
#include<cassert>
#include<ctime>
#include<cstring>
#define rg register
#define il inline
#define co const
template<class T>il T read()
{
    rg T data=0;
    rg int w=1;
    rg char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-')
            w=-1;
        ch=getchar();
    }
    while(isdigit(ch))
    {
        data=data*10+ch-'0';
        ch=getchar();
    }
    return data*w;
}
template<class T>T read(T&x)
{
    return x=read<T>();
}
typedef long long ll;

co int N=2e5+7;
int tot;
int root[N];
int can[N],cantop;
namespace T
{
    using std::swap;

    int ch[N<<6][2],siz[N<<6];
    int pri[N<<6],val[N<<6];
    ll sum[N<<6];
    bool rev[N<<6];

    int newnode(int v=0)
    {
        int x=cantop?can[cantop--]:++tot;
        ch[x][0]=ch[x][1]=0,siz[x]=1;
        pri[x]=rand()<<15|rand(),val[x]=sum[x]=v;
        rev[x]=0;
        return x;
    }

    int clone(int y)
    {
        int x=cantop?can[cantop--]:++tot;
        ch[x][0]=ch[y][0],ch[x][1]=ch[y][1],siz[x]=siz[y];
        pri[x]=pri[y],val[x]=val[y],sum[x]=sum[y];
        rev[x]=rev[y];
        return x;
    }

    void pushup(int x)
    {
        siz[x]=siz[ch[x][0]]+1+siz[ch[x][1]];
        sum[x]=sum[ch[x][0]]+val[x]+sum[ch[x][1]];
    }

    void pushdown(int x)
    {
        if(rev[x])
        {
            swap(ch[x][0],ch[x][1]);
            if(ch[x][0])
            {
                ch[x][0]=clone(ch[x][0]);
                rev[ch[x][0]]^=1;
            }
            if(ch[x][1])
            {
                ch[x][1]=clone(ch[x][1]);
                rev[ch[x][1]]^=1;
            }
            rev[x]=0;
        }
    }

    void split(int x,int k,int&l,int&r)
    {
        if(!x)
        {
            l=r=0;
            return;
        }
        pushdown(x);
        if(k<=siz[ch[x][0]])
        {
            r=clone(x);
            split(ch[r][0],k,l,ch[r][0]);
            pushup(r);
        }
        else
        {
            l=clone(x);
            split(ch[l][1],k-siz[ch[x][0]]-1,ch[l][1],r);
            pushup(l);
        }
    }

    int merge(int x,int y)
    {
        if(!x||!y)
            return x+y;
        if(pri[x]<pri[y])
        {
            pushdown(y);
            ch[y][0]=merge(x,ch[y][0]);
            pushup(y);
            return y;
        }
        else
        {
            pushdown(x);
            ch[x][1]=merge(ch[x][1],y);
            pushup(x);
            return x;
        }
    }

    void insert(int&rt,int k,int v)
    {
        int x,y;
        split(rt,k,x,y);
        rt=merge(x,merge(newnode(v),y));
    }

    void erase(int&rt,int p)
    {
        int x,y,z;
        split(rt,p,x,z);
        split(x,p-1,x,y);
        can[++cantop]=y;
        rt=merge(x,z);
    }

    void reverse(int&rt,int l,int r)
    {
        int x,y,z;
        split(rt,r,x,z);
        split(x,l-1,x,y);
        rev[y]^=1;
        rt=merge(x,merge(y,z));
    }

    ll query(int&rt,int l,int r)
    {
        int x,y,z;
        split(rt,r,x,z);
        split(x,l-1,x,y);
        ll ans=sum[y];
        rt=merge(x,merge(y,z));
        return ans;
    }
}
using namespace T;
using namespace std;

int main()
{
//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);
    int n=read<int>();
    ll lastans=0;
    for(int i=1;i<=n;++i)
    {
        int v,q;
        read(v),read(q);
        root[i]=root[v];
        if(q==1)
        {
            int p,x;
            read(p),read(x);
            p^=lastans,x^=lastans;
            insert(root[i],p,x);
        }
        else if(q==2)
        {
            int p;
            read(p);
            p^=lastans;
            erase(root[i],p);
        }
        else if(q==3)
        {
            int l,r;
            read(l),read(r);
            l^=lastans,r^=lastans;
            reverse(root[i],l,r);
        }
        else
        {
            int l,r;
            read(l),read(r);
            l^=lastans,r^=lastans;
            printf("%lld\n",lastans=query(root[i],l,r));
        }
    }
    return 0;
}