【CF633H】Fibonacci-ish II（权值线段树）（莫队）

给定一个长度最大为30000的序列，和最多30000个询问，每个询问问某区间[L,R]里的数，去掉重复然后排序之后，依次乘上斐波那契数列然后求和，结果对m取余的值

Sample Input
5 10
2 1 2 1 2
2
2 4
4 5
Sample Output
3
3

我们这题先离散化并去重，然后我们考虑莫队。

考虑新加入一个数和删除一个数对答案产生的影响。

加入一个数

我们如果这个数在序列中不是第一次出现，不用管他。

如果是第一次出现，权值线段树求的他的值和在排序去重后的斐波那契数列里的项的乘积。

我们要便于修改，所以我们要记录上一次和这一次的答案值，

比如说$(b,a+b)$,我们保存了$(a,b)$,我们就可以算出$(b,a+b)$,所以我们用一个$pre$和一个$now$,来保存上一个的乘积和这一个的乘积。然后答案就是$now[1]$。

删除一个数也是这样。

void work(int hao,int l,int r,int x)
{
	if(l==r)
	{
		pre[hao]=now[hao]=0;
		return;
	}
	if(tag[hao])
	{
		down(hao);
	}
	int mid=(l+r)/2;
	if(x<=mid)
	{
		work(hao<<1,l,mid,x);
		make_tag(hao<<1|1,-1);//左边会对右边的排名产生影响
	}else{
		work(hao<<1|1,mid+1,r,x);
	}
	up(hao);
}

删除一个数

我们如果这个数在序列中不是最后一次出现，不用管他。

我们像插入一样在权值线段树中修改即可。

记得懒标记

#include<bits/stdc++.h>
#define N 30010
using namespace std;
struct data
{
	int l,r,id1,id;
}q[N];
int b[N],a[N],pre[N<<2],now[N<<2],tag[N<<2],maxn,f[N*3],mod,n,id[N],cnt[N],num[N],p,ans[N];
bool cmp(int x,int y)
{
	return a[x]<a[y];
}
bool cmp1(data a,data b)
{
	if(a.id!=b.id)
	{
		return a.l<b.l;
	}
	return a.r<b.r;
}
void make_tag(int hao,int x)
{
	int xx=(1ll*pre[hao]*f[maxn+x-1]+1ll*now[hao]*f[maxn+x])%mod;//f[i-1]*f[c-1]+f[i]*f[c]=f[i+c]
	int yy=(1ll*pre[hao]*f[maxn+x]+1ll*now[hao]*f[maxn+x+1])%mod;
	tag[hao]+=x;
	pre[hao]=xx;
	now[hao]=yy;
}
void down(int hao)
{
	make_tag(hao<<1,tag[hao]);
	make_tag(hao<<1|1,tag[hao]);
	tag[hao]=0;
}
void up(int hao)
{
	pre[hao]=(pre[hao<<1]+pre[hao<<1|1])%mod;
	now[hao]=(now[hao<<1]+now[hao<<1|1])%mod;
}
void work(int hao,int l,int r,int x)
{
	if(l==r)
	{
		pre[hao]=now[hao]=0;
		return;
	}
	if(tag[hao])
	{
		down(hao);
	}
	int mid=(l+r)/2;
	if(x<=mid)
	{
		work(hao<<1,l,mid,x);
		make_tag(hao<<1|1,-1);//权值线段树左边会对右边产生影响，所以要懒标记记录 
	}else{
		work(hao<<1|1,mid+1,r,x);//而右边对于左边则不会 
	}
	up(hao);
}
void work1(int hao,int l,int r,int x)
{
	if(l==r)
	{
		pre[hao]=(1ll*id[x]*f[maxn+tag[hao]])%mod;
		now[hao]=(1ll*id[x]*f[maxn+tag[hao]+1])%mod;
		return;
	}
	if(tag[hao])
	{
		down(hao);
	}
	int mid=(l+r)/2;
	if(x<=mid)
	{
		work1(hao<<1,l,mid,x);
		make_tag(hao<<1|1,1);
	}else{
		work1(hao<<1|1,mid+1,r,x);
	}
	up(hao);
}
void del(int x)
{
	cnt[x]--;
	if(cnt[x]==0)//不是最后一个不理 
	{
		work(1,1,maxn,x);
	}
}
void sum(int x)
{
	cnt[x]++;
	if(cnt[x]==1)//不是第一个不理 
	{
		work1(1,1,maxn,x);
	}
}
int main()
{
	scanf("%d%d",&n,&mod);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		b[i]=i;
	}
	sort(b+1,b+n+1,cmp);
	num[b[1]]=++maxn;//离散化 
	id[maxn]=a[b[1]];
	for(int i=2;i<=n;i++)
	{
		if(a[b[i]]!=a[b[i-1]])
		{
			maxn++;
		}
		num[b[i]]=maxn;
		id[maxn]=a[b[i]];
	}
	f[maxn+1]=f[maxn+2]=1;//预处理斐波那契 
	for(int i=maxn+3;i<=maxn*2;i++)
	{
		f[i]=f[i-1]+f[i-2]>=mod?f[i-1]+f[i-2]-mod:f[i-1]+f[i-2];
	}
	for(int i=maxn;i>=0;i--)
	{
		f[i]=f[i+2]-f[i+1]<0?f[i+2]-f[i+1]+mod:f[i+2]-f[i+1];
	}
	int kkk=sqrt(n);
	scanf("%d",&p);
	for(int i=1;i<=p;i++)
	{
		scanf("%d%d",&q[i].l,&q[i].r);
		q[i].id=(q[i].l-1)/kkk;
		q[i].id1=i;
	}
	sort(q+1,q+p+1,cmp1);
	int ll=q[1].l,rr=q[1].l-1;
	for(int i=1;i<=p;i++)//莫队 
	{
		while(ll<q[i].l)
		{
			del(num[ll]);
			ll++;
		}
		while(rr<q[i].r)
		{
			rr++;
			sum(num[rr]);
		}
		while(ll>q[i].l)
		{
			ll--;
			sum(num[ll]);
		}
		while(rr>q[i].r)
		{
			del(num[rr]);
			rr--;
		}
		ans[q[i].id1]=now[1];
		while(ans[q[i].id1]<0)
		{
			ans[q[i].id1]+=mod;
		}
	}
	for(int i=1;i<=p;i++)
	{
		printf("%d\n",ans[i]);
	}
	return 0;
}