「刷题笔记」莫队

莫队算法——从入门到黑题 by WAMonster
（感谢yspm的推荐

板子

对位置进行分块，记录询问每个端点所属的块，排序时，左端点按所属的块排序，右端点按原位置排序
淦发现之前在博客里发出了“莫队左端点移动O(n)”的暴论
排序后，左端点移动的次数是(O(nsqrt{n}))的，
而右端点在每个相同左端点中递增，移动的次数是(O(nsqrt{n}))，所以算法总复杂度为(O(nsqrt{n}))
还有一些奇怪的优化比如奇偶性排序，但是并不会证只能先背过了……

SP3267 DQUERY - D-query

code:

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define N 30005
#define Q 200005
#define C 1000005

ll n,a[N],bel[N];
ll q;
struct query
{
	ll a,b,id;
	ll aa,bb;
	bool operator<(const query &y)const
	{
		return aa==y.aa?b<y.b:aa<y.aa;
	}
}qq[Q];

inline ll read()
{
	ll f=0,s=0; char c=getchar();
	while(c>'9'||c<'0')f=(c=='-'),c=getchar();
	while(c>='0'&&c<='9')s=(s<<3)+(s<<1)+(c^'0'),c=getchar();
	return f?-s:s;
}

ll cnt[C];
ll an=0;
ll ans[Q];

void add(ll x)
{
	if(!cnt[a[x]])an++;
	cnt[a[x]]++;
}

void del(ll x)
{
	cnt[a[x]]--;
	if(!cnt[a[x]])an--;
}

int main()
{
	n=read();
	for(int i=1;i<=n;i++)a[i]=read();
	ll S=sqrt(n)+1;
	for(int i=1;i<=n;i++)bel[i]=(i-1)/S+1;
	q=read();
	for(int i=1;i<=q;i++)
	{
		qq[i].a=read(),qq[i].b=read(),qq[i].id=i;
		qq[i].aa=bel[qq[i].a],qq[i].bb=bel[qq[i].b];
	}
	sort(qq+1,qq+q+1);
	ll l=1,r=0;
	for(int i=1;i<=q;i++)
	{
		ll nl=qq[i].a,nr=qq[i].b;
		while(nl>l)del(l++);
		while(nl<l)add(--l);
		while(nr>r)add(++r);
		while(nr<r)del(r--);
		ans[qq[i].id]=an;
	}
	for(int i=1;i<=q;i++)printf("%lld
",ans[i]);
	return 0;
}

luogu P2709 小B的询问

一个挺有用的统计平方和的套路：从(a^2)到((a+1)^2)，即为加上(2a+1)
所以只需要统计每种颜色当前区间内的出现次数就好

二维莫队

蔬菜

原理和一维差不多，只不过是相当于区间变成了矩形，所以移动的时候要对一个区间进行加加减减
用二维莫队就可以转化成和小B的询问套路相同的题

带修莫队

P1903 [国家集训队]数颜色 / 维护队列

与普通莫队的区别在于支持修改，当然莫队需要离线
若强制在线就得考虑别的方法了，但是如果支持修改且可以离线有时就可以考虑带修莫队
为了支持修改，带修莫队需要在普通莫队的基础上加一个时间戳，时间戳记录的是每个询问上一个修改操作的时间，
把修改操作单独储存后，就可以通过时间戳的加减来实现对于某个区间答案的时间变换
感性理解：就是由原来的((l+1,r))，((l-1,r))，((l,r+1))，((l,r-1))四个方向的转移
变成了((l+1,r,t))，((l-1,r,t))，((l,r+1,t))，((l,r-1,t))，((l,r,t+1))，((l,r,t-1))六个方向的转移
转移的时候需要记录当前值以备转移回去，可以直接把当前值与修改操作中的修改值交换，这样回来的时候就能直接换回去
奇偶性排序直接12s->5s是什么操作

code:

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define N 133350
#define C 1000005

ll n,m;
ll a[N];
ll cnt[C],ans[N];

struct query
{
	ll l,r,t,id;
	ll lb,rb;
	bool operator<(const query &y)const
	{
		return (lb^y.lb)?lb<y.lb:(rb^y.rb)?rb<y.rb:t<y.t;
	}
}q[N];
ll qcn=0;

struct update
{
	ll x,v;
}c[N];

inline ll read()
{
	ll f=0,s=0; char c=getchar();
	while(c>'9'||c<'0')f=(c=='-'),c=getchar();
	while(c>='0'&&c<='9')s=(s<<3)+(s<<1)+(c^'0'),c=getchar();
	return f?-s:s;
}

ll ti=0,an=0;
char ch[2];

void add(ll x=0,ll c=0)
{
	if(x)
	{
		if(cnt[a[x]]==0)an++;
		cnt[a[x]]++;
	}
	else if(c)
	{
		if(cnt[c]==0)an++;
		cnt[c]++;
	}
}

void del(ll x=0,ll c=0)
{
	if(x)
	{
		cnt[a[x]]--;
		if(cnt[a[x]]==0)an--;
	}
	else if(c)
	{
		cnt[c]--;
		if(cnt[c]==0)an--;
	}
}

int main()
{
	n=read(); m=read();
	ll S=pow(n,3.0/4.0);
	for(int i=1;i<=n;i++)a[i]=read();
	for(int i=1;i<=m;i++)
	{
		scanf("%s",ch);
		if(ch[0]=='Q')
		{
			q[++qcn].l=read(),q[qcn].r=read(),q[qcn].t=ti,q[qcn].id=qcn;
			q[qcn].lb=(q[qcn].l-1)/S+1,q[qcn].rb=(q[qcn].r-1)/S+1;
		}
		else if(ch[0]=='R')
		{
			c[++ti].x=read(),c[ti].v=read();
		}
	}
	sort(q+1,q+qcn+1);
	ll l=1,r=0,t=0;
	for(int i=1;i<=qcn;i++)
	{
		ll nl=q[i].l,nr=q[i].r,lt=q[i].t;
		while(l<nl)del(l++,0);
		while(l>nl)add(--l,0);
		while(r<nr)add(++r,0);
		while(r>nr)del(r--,0);
		while(t>lt)
		{
			if(nl<=c[t].x&&c[t].x<=nr)del(c[t].x,0),add(0,c[t].v);
			swap(a[c[t].x],c[t].v);
			t--;
		}
		while(t<lt)
		{
			t++;
			if(nl<=c[t].x&&c[t].x<=nr)del(c[t].x,0),add(0,c[t].v);
			swap(a[c[t].x],c[t].v);
		}
		ans[q[i].id]=an;
	}
	for(int i=1;i<=qcn;i++)printf("%lld
",ans[i]);
	return 0;
}

树上莫队

SP10707 COT2

考虑怎样把树上的点转化成一个容易用莫队处理的序列，那么可以使用欧拉序
考虑路径((u,v)(dep_u<dep_v))上的点在欧拉序里是怎么表现的
首先，忽略在一段欧拉序中出现两次的点，这些点不在所求路径上
记点(k)在欧拉序中第一次出现在(fi_k)，最后一次出现在(la_k)，那么：

• 如果(lca(u,v)=u)，那么所求区间为([fi_u,fi_v])
• 否则，所求区间为([la_u,fi_v])，但这个区间不包含他们的lca，这时lca要单独处理

这样，就可以用莫队处理树上的问题了

code:

#include<bits/stdc++.h>
using namespace std;
#define ll int
#define ull unsigned long long
#define N 200005
#define gc() (p1==p2?(p2=buf+fread(p1=buf,1,1<<20,stdin),p1==p2?EOF:*p1++):*p1++)
char buf[1<<20],*p1,*p2;

ll n,m;
ll w[N],b[N],tot=0;
ll t1,t2;

ll v[N];
ll h[N],nx[N],tt=0;

void add(ll a,ll b){
	v[++tt]=b;
	nx[tt]=h[a];
	h[a]=tt;
}

ll bel[N];
struct query{
	ll l,r,id,lc;
	ll lb,rb;
	bool operator<(const query &b)const{
		return (bel[l]^bel[b.l])?(bel[l]<bel[b.l]):((bel[l]&1)?r<b.r:r>b.r);
	}
}q[N];

ll a[N*2],fi[N],la[N],cnt=0;
ll fa[N][21],dep[N];
void dfs(ll u,ll f){
	a[++cnt]=u;
	fa[u][0]=f;
	dep[u]=dep[f]+1;
	fi[u]=cnt;
	for(int i=1;i<=20;i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	for(int i=h[u];i;i=nx[i]){
		if(v[i]==f)continue;
		dfs(v[i],u);
	}
	a[++cnt]=u;
	la[u]=cnt;
}

inline int lca(int u,int v){
	if(dep[u]<dep[v])swap(u,v);
	for(int i=20;i>=0;--i)if(dep[u]-(1<<i)>=dep[v])u=fa[u][i];
	if(u==v)return u;
	for(int i=20;i>=0;--i)if(fa[u][i]!=fa[v][i])u=fa[u][i],v=fa[v][i];
	return fa[u][0];
}

bool vis[N];
ll cn[N];
ll an=0,ans[N];
inline void work(int pos){
	vis[pos]?an-=!--cn[w[pos]]:an+=!cn[w[pos]]++;
	vis[pos]^=1;
}

inline ll read(){
	ll f=0,s=0; char c=gc();
	while(c>'9'||c<'0')f=(c=='-'),c=gc();
	while(c>='0'&&c<='9')s=(s<<3)+(s<<1)+(c^'0'),c=gc();
	return f?-s:s;
}

int main(){
	n=read(), m=read();
	for(int i=1;i<=n;i++)w[i]=read(),b[++tot]=w[i];
	sort(b+1,b+tot+1); tot=unique(b+1,b+tot+1)-b-1;
	for(int i=1;i<=n;i++)w[i]=lower_bound(b+1,b+tot+1,w[i])-b;//cout<<w[i]<<' ';cout<<endl;
	for(int i=1;i<n;i++)t1=read(),t2=read(),add(t1,t2),add(t2,t1);
	dfs(1,0);
	ll S=sqrt(cnt),bnum=ceil((double)cnt/S);
	for(int i=1;i<=bnum;++i)for(int j=S*(i-1)+1;j<=i*S;++j){
		bel[j]=i;
	}
	for(int i=1;i<=m;i++){
		q[i].l=read(),q[i].r=read(),q[i].id=i;
		ll tlc=lca(q[i].l,q[i].r);
		if(fi[q[i].l]>fi[q[i].r])swap(q[i].l,q[i].r);
		if(tlc==q[i].l)q[i].l=fi[q[i].l],q[i].r=fi[q[i].r];
		else q[i].l=la[q[i].l],q[i].r=fi[q[i].r],q[i].lc=tlc;
	}
	sort(q+1,q+m+1);
	ll l=1,r=0;
	for(int i=1;i<=m;i++){
		ll nl=q[i].l,nr=q[i].r;
		while(l<nl)work(a[l++]);
		while(l>nl)work(a[--l]);
		while(r<nr)work(a[++r]);
		while(r>nr)work(a[r--]);
		if(q[i].lc)work(q[i].lc);
		ans[q[i].id]=an;
		if(q[i].lc)work(q[i].lc);
	}
	for(int i=1;i<=m;i++)printf("%d
",ans[i]);
	return 0;
}

需要注意的：

• 莫队中的分块，在点的编号较小，询问较多时，先统一求出每个数所属的块，不用每个询问单独算
• lca倍增预处理(lg)数组会变慢，最好直接根据数据范围定下上界（21，31这种的）

要是这两点出了岔子程序效率就会极其低……

回滚莫队

有时候题目中并不是很好实现莫队移动区间时的“删除”操作，这时可以用回滚莫队来绕开删除的不便
具体的实现是把询问按左端点所属的块排序，块内按右端点编号排序，左右端点在同一块就暴力算，否则右端点从当前块右端出发向右走（这个移动排序后是单调的），左端点每次从当前块右端向左走，处理完每个询问后再把左端点移到块右端，并把答案恢复到上一次左端点走之前的状态
具体细节见代码

洛谷 P5906 【模板】回滚莫队&不删除莫队

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define N 200005

ll n,m,a[N],b[N],S,tot=0;
ll bel[N];

struct query{
	ll l,r,id;
	inline bool operator<(const query &b)const{
		return (bel[l]==bel[b.l])?(r<b.r):(bel[l]<bel[b.l]);
	}
}q[N];
ll pre[N],lst[N],ans[N];
ll st[N],tp=0;

inline ll work(ll l,ll r){ ll an=0;
	for(int i=l;i<=r;i++){
		if(!pre[a[i]])pre[a[i]]=i,st[++tp]=a[i];
		an=max(an,i-pre[a[i]]);
	}
	while(tp)pre[st[tp]]=0,tp--;
	return an;
}

inline ll read(){
	ll f=0,s=0; char c=getchar();
	while(c>'9'||c<'0')f=(c=='-'),c=getchar();
	while(c>='0'&&c<='9')s=(s<<3)+(s<<1)+(c^'0'),c=getchar();
	return f?-s:s;
}

int main(){
	n=read(); for(int i=1;i<=n;i++)a[i]=b[++tot]=read();
	m=read(); for(int i=1;i<=m;i++)q[i].l=read(), q[i].r=read(), q[i].id=i;
	S=sqrt(n)+1; for(int i=1;i<=n;i++)bel[i]=(i-1)/S+1;
	sort(b+1,b+tot+1); tot=unique(b+1,b+tot+1)-b-1;
	for(int i=1;i<=n;i++)a[i]=lower_bound(b+1,b+tot+1,a[i])-b;
	sort(q+1,q+m+1);
	for(int i=1,j=1;i<=S;i++){ ll br=i*S, l=br+1, r=br, an=0;
		for(;bel[q[j].l]==i;j++){ ll ql=q[j].l, qr=q[j].r;
			if(bel[ql]==bel[qr]){ ans[q[j].id]=work(ql,qr); continue; }
			while(r<qr){
				r++; lst[a[r]]=r;
				if(!pre[a[r]])pre[a[r]]=r,st[++tp]=a[r]; an=max(an,r-pre[a[r]]);
			}
			ll tmp=an;
			while(l>ql){
				l--; if(!lst[a[l]])lst[a[l]]=l,st[++tp]=a[l];
				an=max(an,lst[a[l]]-l);
			}
			ans[q[j].id]=an;
			while(l<=br){
				if(lst[a[l]]==l)lst[a[l]]=0; l++;
			}
			an=tmp;
		}
		while(tp)pre[st[tp]]=lst[st[tp]]=0,tp--;
	}
	for(int i=1;i<=m;i++)printf("%lld
",ans[i]);
	return 0;
}