【洛谷5072】[Ynoi2015] 盼君勿忘（莫队）
大致题意： 一个序列，每次询问一个区间\([l,r]\)并给出一个模数\(p\)，求模\(p\)意义下区间\([l,r]\)内所有子序列去重后值的和。
题意转化
原来的题意看起来似乎很棘手，因此需要一定的转化。
考虑一个值\(x\)的贡献，设它在区间中出现的次数为\(cnt_x\)，则共有\(2^{r-l+1}-2^{r-l+1-cnt_x}\)个子序列中有这个值，因此它的贡献就是\(x\cdot (2^{r-l+1}-2^{r-l+1-cnt_x})\)。
经这么一转化，不难发现，要求出这个式子的值，我们需要高效维护出区间内每个数的出现次数。
怎么维护呢？结合题目来源是Ynoi，我们不难想到莫队。
计算答案
通过莫队，我们能够在\(O(n\sqrt n)\)的时间内轻松求出\(cnt_x\)。
但必须要注意此题最大的坑点，因为模数是由询问给出的，所以我们无法直接维护答案中\(2\)的幂。
那么，我们就需要考虑，如何在维护\(cnt_x\)的基础上，对于每个询问，在\(O(\sqrt n)\)的时间内快速计算出答案。
研究\(x\cdot (2^{r-l+1}-2^{r-l+1-cnt_x})\)这个式子，可以发现在\(cnt\)相等时，后面\(2\)的幂是相同的，因此我们可以想到设\(sum_i=\sum_{cnt_x=i} x\)，则答案就是\(\sum sum_i\cdot(2^{r-l+1}-2^{r-l+1-i})\)。
\(sum_i\)可以在维护\(cnt_x\)的时候一同维护，但如果我们求答案时真的去枚举\(i\)，复杂度依然是\(O(n)\)。
所以我们可以考虑根号分治：
- 对于\(cnt_x\le\sqrt n\)，我们直接枚举这\(\sqrt n\)个\(sum_i\)计算答案，单次询问复杂度为\(O(\sqrt n)\)。
- 对于\(cnt_x>\sqrt n\)，由于\(\sum cnt_x=r-l+1\le n\)，因此这样的\(x\)不超过\(\sqrt n\)个，可以在莫队同时用链表维护，然后询问时扫描链表计算答案，单次询问复杂度为\(O(\sqrt n)\)。
这样一来复杂度就做到了\(O(n\sqrt n)\)。
预处理\(2\)的幂——真正的\(O(n\sqrt n)\)
注意，如果用快速幂来求\(2\)的幂，显然，会让复杂度多带一个\(log\)，这就让原本已经较高的复杂度更是难以接受，因此需要想办法去掉这个\(log\)。
怎样才能做到呢？很简单，其实预处理一下就可以了。
由于模数是询问中给出的，所以我们需要对于每个询问\(O(\sqrt n)\)预处理出\(2\)的幂。
实际上，我们只需预处理\(p2_i=2^i,p1_i=2^{i\sqrt n}\)，然后就能实现\(O(\sqrt n)\)预处理、\(O(1)\)计算了。
代码
#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 100000
using namespace std;
int n,Bs,Qt,a[N+5];
struct Query
{
int l,r,X,p,bl;I Query(CI x=0,CI y=0,CI g=0,CI i=0):l(x),r(y),X(g),p(i){Bs&&(bl=(x-1)/Bs+1);}
I bool operator < (Con Query& o) Con {return bl^o.bl?bl<o.bl:(bl&1?r<o.r:r>o.r);}
}q[N+5];
I int Qpow(RI x,RI y,RI X) {RI t=1;W(y) y&1&&(t=1LL*t*x%X),x=1LL*x*x%X,y>>=1;return t;}
class FastIO
{
private:
#define FS 100000
#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
#define pc(c) (C==E&&(clear(),0),*C++=c)
#define tn (x<<3)+(x<<1)
#define D isdigit(c=tc())
int T;char c,*A,*B,*C,*E,FI[FS],FO[FS],S[FS];
public:
I FastIO() {A=B=FI,C=FO,E=FO+FS;}
Tp I void read(Ty& x) {x=0;W(!D);W(x=tn+(c&15),D);}
Tp I void write(Ty x) {W(S[++T]=x%10+48,x/=10);W(T) pc(S[T--]);}
Tp I void writeln(Con Ty& x) {write(x),pc('\n');}
I void clear() {fwrite(FO,1,C-FO,stdout),C=FO;}
}F;
class MoQueueSolver
{
private:
#define P(x) (1LL*p1[(x)/Bs]*p2[(x)%Bs]%X)//计算2的幂
#define Ins(x) (nxt[x]=lnk,lst[lnk]=x,lnk=x)//链表中插入
#define Kill(x) ((x)^lnk?(lst[nxt[x]]=lst[x],nxt[lst[x]]=nxt[x]):(lnk=nxt[x]))//链表中删除
#define Add(x) cnt[x]==Bs&&Ins(x),cnt[x]<=Bs&&(sum[cnt[x]]-=x),++cnt[x]<=Bs&&(sum[cnt[x]]+=x)//加入元素
#define Del(x) cnt[x]==Bs+1&&Kill(x),cnt[x]<=Bs&&(sum[cnt[x]]-=x),--cnt[x]<=Bs&&(sum[cnt[x]]+=x)//删除元素
int X,ans[N+5],p1[N+5],p2[N+5],cnt[N+5],lnk,lst[N+5],nxt[N+5];long long sum[N+5];
I int Qry(CI l,CI r)//询问答案
{
RI i,p=P(r-l+1),t=0;for(i=1;i<=Bs;++i) t=(1LL*(p-P(r-l+1-i)+X)*(sum[i]%X)+t)%X;//对于小于等于sqrt(n)的部分
for(i=lnk;i;i=nxt[i]) t=(1LL*i*(p-P(r-l+1-cnt[i])+X)+t)%X;return t;//对于大于sqrt(n)的部分
}
public:
I void Solve()
{
RI i,j,L=1,R=0;for(sort(q+1,q+Qt+1),i=1;i<=Qt;++i)//莫队
{
W(R<q[i].r) ++R,Add(a[R]);W(L>q[i].l) --L,Add(a[L]);
W(R>q[i].r) Del(a[R]),--R;W(L<q[i].l) Del(a[L]),++L;
for(X=q[i].X,p1[0]=p2[0]=j=1;j<=Bs;++j) p2[j]=(p2[j-1]<<1)%X;//预处理2的幂
for(j=1;j<=(q[i].r-q[i].l+1)/Bs;++j) p1[j]=1LL*p1[j-1]*p2[Bs]%X;
ans[q[i].p]=Qry(q[i].l,q[i].r);//求解并记下答案
}
for(i=1;i<=Qt;++i) F.writeln(ans[i]);//输出答案
}
}M;
int main()
{
RI i,x,y,z;for(F.read(n),F.read(Qt),Bs=sqrt(n),i=1;i<=n;++i) F.read(a[i]);
for(i=1;i<=Qt;++i) F.read(x),F.read(y),F.read(z),q[i]=Query(x,y,z,i);//读入并存储询问
return M.Solve(),F.clear(),0;
}
