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

【题目】
原题地址
题意：维护一个序列a，要求支持：
操作1：区间求和
操作2：$for(inti=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和成一棵。
具体实现见代码，也可以出门找关于$fhqTreap$的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;
}