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

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

【解题思路】
可持久化Treap学习!(然而这题网上一个题解都没有,心态很崩)

首先可持久化Treap是非旋的,非旋Treap有两种主要操作。
s p l i t ( x , l , r ) split(x,l,r) split(x,l,r):将一棵树 x x x分割出 [ l , r ] [l,r] [l,r]区间,相当于提取一段区间。
m e r g e ( x , y ) merge(x,y) merge(x,y):将两棵树x和y和成一棵。
具体实现见代码,也可以出门找关于 f h q   T r e a p fhq\ Treap fhq Treap的blog。

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

对于操作1:区间求和是平衡树最基本操作之一,在非旋Treap上只需要 s p l i t ( r t , l , r ) split(rt,l,r) split(rt,l,r),然后看提取出的树的 s u m sum sum

对于操作3: s p l i t ( r o o t , l , r ) split(root,l,r) split(root,l,r)可以提取出最老版本的 [ l , r ] [l,r] [l,r]区间,其中 r o o t root root代表初始的根节点编号,然后 s p l i t ( r t , 1 , l − 1 ) split(rt,1,l-1) split(rt,1,l1) s p l i t ( r t , r + 1 , n ) split(rt,r+1,n) split(rt,r+1,n),再 m e r g e merge merge起来即可。

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

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

【参考代码】

#pragma GCC optimize("O3")
#include
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)>=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;
}

你可能感兴趣的:(数据结构-平衡树)