【可持久化Treap+倍增】HDU6087 Rikka with Sequence

【题目】
原题地址
题意：维护一个序列a，要求支持：
操作1：区间求和
操作2：$for(int\ \ i=l;i<=r;++i) a[i]=a[i-k]$
操作3：区间$a[i]=b[i]$，其中$b[i]$等于一开始输入的$a[i]$

【解题思路】
可持久化Treap学习！（然而这题网上一个题解都没有，心态很崩）

首先可持久化Treap是非旋的，非旋Treap有两种主要操作。
$split(x,l,r)$：将一棵树$x$分割出$[l,r]$区间，相当于提取一段区间。
$merge(x,y)$：将两棵树x和y和成一棵。
具体实现见代码，也可以出门找关于$fhq\ Treap$的blog。

观察后发现，这题用可持久化Treap解法自然：
对于平衡树上每个节点维护$ls,rs,val,sz,sum$，分别代表左右孩子，节点权值，子树大小，子树权值和。

对于操作1：区间求和是平衡树最基本操作之一，在非旋Treap上只需要$split(rt,l,r)$，然后看提取出的树的$sum$。

对于操作3：$split(root,l,r)$可以提取出最老版本的$[l,r]$区间，其中$root$代表初始的根节点编号，然后$split(rt,1,l-1)$，$split(rt,r+1,n)$，再$merge$起来即可。

对于操作2：我们发现，若$k<r-l+1$，那么将会出现$[l-k,l-1]$这个区间重复多次后覆盖到$[l,r]$，当$k$比较小而区间比较长时，我们不可能暴力$split$再$merge$。我们可以考虑类似快速幂的操作，将$[l-k,l-1]$倍增多次，直到长度恰好大于等于区间长度，再$split$这棵树使得树的大小为区间长度，最后$merge$回去即可。

要注意的是，这道题目对于空间的限制比较死，所以在若干次操作后应该暴力重构整颗树，还要进行内存回收。这里我取了450次操作重构一次，可以再计算一下更优的重构次数使得用时更小。

【参考代码】

#pragma GCC optimize("O3")
#include<bits/stdc++.h>
using namespace std;

typedef long long LL;
const int N=2e5+10,M=N*4;
int n,Q,rt,root,lim,rtop,utop,top;
int a[N],res[M],used[M];

int read()
{
    int ret=0,f=1;char c=getchar();
    while(!isdigit(c)) {if(c=='-')f=0;c=getchar();}
    while(isdigit(c)) {ret=ret*10+(c^48);c=getchar();}
    return f?ret:-ret;
}

void write(LL x)
{
    if(x>9) write(x/10);
    putchar(x%10^48);   
}

struct node
{
    int ls,rs,val,sz;
    LL sum;
    void init(){ls=rs=val=sz=sum=0;}
};

struct Treap
{
    int ind,pos[M];
    node t[M];

    void init(){t[0].init();}

    int newnode(int val=0)
    {
        int x;
        if(rtop) x=res[rtop--];
            else x=++top;
        used[++utop]=x;
        t[x].ls=t[x].rs=0;t[x].val=val;
        return x;
    }

    void pushup(int x)
    {
        int lc=t[x].ls,rc=t[x].rs;
        t[x].sum=t[lc].sum+t[rc].sum+t[x].val;
        t[x].sz=t[lc].sz+t[rc].sz+1;
    }

    void dfs(int x)
    {
        if(!x) return;
        pos[x]=ind;dfs(t[x].ls);dfs(t[x].rs);
    }

    void rebuild()
    {
        ++ind;dfs(rt);dfs(root);int cnt=0;
        for(int i=1;i<=utop;++i)
        {
            if(pos[used[i]]==ind) used[++cnt]=used[i];
                else res[++rtop]=used[i];
        }
        utop=cnt;
    }

    int build(int l,int r)
    {
        if(l>r) return 0;
        int mid=(l+r)>>1,x=newnode(a[mid]);
        t[x].ls=build(l,mid-1);t[x].rs=build(mid+1,r);
        pushup(x);
        return x;
    }

    int realrnd() {int s=1926081722; return (s+=((s<<3)+1))&(~0u>>1);}
    bool rnd(int x,int y) {return (realrnd()%(x+y)<x);}

    int merge(int x,int y)
    {
        if(!x && !y) return 0;
        int u=newnode();
        if(!x || !y) t[u]=t[x+y];
        else  if(rnd(t[x].sz,t[y].sz)) t[u]=t[x],t[u].rs=merge(t[u].rs,y),pushup(u);
        else t[u]=t[y],t[u].ls=merge(x,t[u].ls),pushup(u);
        return u;
    }

    int qpow(int x,int y)
    {
        int ret=0;
        for(;y;y>>=1,x=merge(x,x)) if(y&1) ret=merge(ret,x);
        return ret;
    }

    int split(int x,int l,int r)
    {
        if(l>r) return 0;
        if(l==1 && r==t[x].sz)
        {
            int u=newnode();t[u]=t[x];
            return u;
        }
        int lc=t[x].ls,rc=t[x].rs,sz=t[lc].sz;
        if(r<=sz) return split(lc,l,r);
        else if(l>sz+1) return split(rc,l-sz-1,r-sz-1);
        else
        {
            int u=newnode(t[x].val);
            t[u].ls=split(lc,l,sz);t[u].rs=split(rc,1,r-sz-1);
            pushup(u);
            return u;
        } 
    }

    LL getsum(int l,int r) {write(t[split(rt,l,r)].sum);puts("");}

    void update(int l,int r,int k)
    {
        int a=split(rt,1,l-k-1),b=split(rt,l-k,l-1);
        int c=qpow(b,(r-l+1)/k);
        int d=split(rt,l-k,l-k-1+(r-l+1)%k),e=split(rt,r+1,n);
        rt=merge(a,b);rt=merge(rt,c);rt=merge(rt,d);rt=merge(rt,e);
    }

    void copy(int l,int r)
    {
        int a=split(rt,1,l-1),b=split(root,l,r),c=split(rt,r+1,n);
        rt=merge(a,b);rt=merge(rt,c);
    }
}tr;

int main()
{
    freopen("HDU6087.in","r",stdin);
    freopen("HDU6087.out","w",stdout);

    n=read();Q=read();lim=450;tr.init();
    for(int i=1;i<=n;++i) a[i]=read();
    rt=root=tr.build(1,n);
    while(Q--)
    {
        int opt=read(),l=read(),r=read(),k;
        if(!(Q%lim)) tr.rebuild();
        if(opt==1) tr.getsum(l,r);
        else if(opt==2) k=read(),tr.update(l,r,k);
        else tr.copy(l,r);
    }

    return 0;
}