莫队

莫队

莫队算法的本质是一种暴力。

在一些区间（或树）上的问题，没有强制要求在线时，将区间（或树）上问题转换为离线去做。

1.普通莫队

算法介绍：

普通莫队，就是可离线，没有修改的莫队。这一类莫队算法的核心思想是：将整个数列区间划分$sqrt{n}$块。再将多个询问进行升序$sort()$，改变处理问题的顺序，即第一关键字为询问左区间l所在第几个块，第二关键字为询问右区间r。

用两个指针，$ll=1$和$rr=0$（保证开始为一个空区间）。从左到右处理所有询问。

在当前询问区间$[l_1,r_1]$向下一个询问区间$[l_2,r_2]$转移时，只需要处理两个指针在跳动过程中所经过的值就好。

核心代码：

ll=1,rr=0,cnt=0;
for (int i=0;i<m;i++){
    while (ll<b[i].l) del(ll++);
    while (ll>b[i].l) add(--ll);
    while (rr<b[i].r) add(++rr);
    while (rr>b[i].r) del(rr--);
    ans[b[i].id]=cnt;
}

复杂度：

用$B$代表块的大小。

对于$l$指针每次移动$O(B)$，对于指针$r$每次移动整个区间大小$O(n)$。

所以，对于$l$指针，移动次数最多为询问数×块的大小，即$O(m×B)$；

对于$r$指针，移动次数最多为块的个数×总区间大小，即$O(frac{n}{B}×n)$。

所以总的移动次数为：$O(m×B+frac{n}{B}×n)$。

可以看出这事一个对勾函数。

所以，当$B=sqrt{frac{n^2}{m}}$，即$B=frac{n}{sqrt{m}}$时，复杂度最小，为$O(nsqrt{m})$。

 

例.bzoj1878 [SDOI2009]HH的项链

传送：https://www.lydsy.com/JudgeOnline/problem.php?id=1878

题意：n个物品，每个物品有一个颜色，问区间$[l,r]$内有多少种颜色。

分析：莫队模板。

#include<bits/stdc++.h>
using namespace std;
const int maxm=2e5+10;
const int maxn=5e4+10;
const int maxnum=1e6+10;
struct node{
    int l,r,blo,id;
    bool operator <(node q)const{
        return blo<q.blo || blo==q.blo && r<q.r;
    }
}b[maxm];
int a[maxn],ans[maxm];
int block,ll,rr,cnt;
int num[maxnum];
void add(int x){
    int tmp=a[x];
    if (num[tmp]==0) cnt++;
    num[tmp]++;
}
void del(int x){
    int tmp=a[x];
    if (num[tmp]==1) cnt--;
    num[tmp]--;
}
int main(){
    int n; scanf("%d",&n);
    block=sqrt(n);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    int m; scanf("%d",&m);
    for (int i=0;i<m;i++){
        scanf("%d%d",&b[i].l,&b[i].r);
        b[i].blo=b[i].l/block;
        b[i].id=i;
    }
    sort(b,b+m);
    memset(num,0,sizeof(num));
    ll=1,rr=0,cnt=0;
    for (int i=0;i<m;i++){
        while (ll<b[i].l) del(ll++);
        while (ll>b[i].l) add(--ll);
        while (rr<b[i].r) add(++rr);
        while (rr>b[i].r) del(rr--);
        ans[b[i].id]=cnt;
    }
    for (int i=0;i<m;i++) printf("%d
",ans[i]);
    return 0; 
} 

 练习：

1.bzoj2038 小Z的袜子(hose)

传送：https://www.lydsy.com/JudgeOnline/problem.php?id=2038

题意：有n个袜子，每个袜子有一个颜色。m个询问，询问在一个区间$[l,r]$内，选择两种相同颜色的袜子的概率。

分析：莫队。将询问排序。每次转移时，$cnt$先减去$num[tmp]*num[tmp]$；更新$num$后，再加上$num[tmp]*num[tmp]$。最后的答案就是$cnt-b[i].len/b[i].len*(b[i].len-1)$。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=5e4+10;
struct node{
    int l,r,blo,id;
    bool operator <(node p)const{
        return blo<p.blo || blo==p.blo && r<p.r;
    }
}b[maxn];
struct node2{
    ll a,b;
}ans[maxn];
int a[maxn];
ll num[maxn];
int ll_,rr_,block;
ll cnt;
void add(int x){
    int tmp=a[x];
    cnt-=num[tmp]*num[tmp];
    num[tmp]++;
    cnt+=num[tmp]*num[tmp];
}
void del(int x){
    int tmp=a[x];
    cnt-=num[tmp]*num[tmp];
    num[tmp]--;
    cnt+=num[tmp]*num[tmp];
}
ll calc(node p){
    return 1ll*(p.r-p.l+1)*(p.r-p.l);
}
ll gcd_(ll x,ll y){
    if (y==0) return x;
    else return gcd_(y,x%y);
}
int main(){
    int n,m; scanf("%d%d",&n,&m);
    block=sqrt(n);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    for (int i=0;i<m;i++){
        scanf("%d%d",&b[i].l,&b[i].r);
        b[i].blo=b[i].l/block;
        b[i].id=i;
    } 
    sort(b,b+m);
    ll_=1,rr_=0,cnt=0;
    memset(num,0,sizeof(num));
    for (int i=0;i<m;i++){
        while (ll_<b[i].l) del(ll_++);
        while (ll_>b[i].l) add(--ll_);
        while (rr_<b[i].r) add(++rr_);
        while (rr_>b[i].r) del(rr_--);
        ans[b[i].id].a=cnt-(b[i].r-b[i].l+1);
        ans[b[i].id].b=calc(b[i]);
    }
    for (int i=0;i<m;i++){
        ll tmp=gcd_(ans[i].a,ans[i].b);
        ans[i].a/=tmp; ans[i].b/=tmp;
        if (ans[i].a==0) printf("0/1
");
        else printf("%lld/%lld
",ans[i].a,ans[i].b);
    }
    return 0;
}

2.洛谷2709 小B的询问

题意：rt。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=5e4+10;
struct node{
    int l,r,blo,id;
    bool operator <(node p)const{
        return blo<p.blo || blo==p.blo && r<p.r;
    }
}b[maxn];
int a[maxn],num[maxn],l,r;
ll cnt;
ll ans[maxn]; 
void add(int x){
    int tmp=a[x];
    cnt-=1ll*num[tmp]*num[tmp];
    num[tmp]++;
    cnt+=1ll*num[tmp]*num[tmp];
}
void del(int x){
    int tmp=a[x];
    cnt-=1ll*num[tmp]*num[tmp];
    num[tmp]--;
    cnt+=1ll*num[tmp]*num[tmp];
}
int main(){
    int n,m,k; scanf("%d%d%d",&n,&m,&k);
    int block=sqrt(n);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    for (int i=0;i<m;i++){
        scanf("%d%d",&b[i].l,&b[i].r);
        b[i].blo=b[i].l/block;
        b[i].id=i;
    }
    sort(b,b+m);
    l=1,r=0,cnt=0;
    memset(num,0,sizeof(num));
    for (int i=0;i<m;i++){
        while (l<b[i].l) del(l++);
        while (l>b[i].l) add(--l);
        while (r<b[i].r) add(++r);
        while (r>b[i].r) del(r--);
        ans[b[i].id]=cnt;
    }
    for (int i=0;i<m;i++) printf("%lld
",ans[i]);
    return 0;
} 

2.带修莫队

算法介绍：

还是对询问进行排序，每个询问除了左端点和右端点还要记录这次询问是在第几次修改之后（时间），以左端点所在块为第一关键字，以右端点所在块为第二关键字，以时间为第三关键字进行排序。

暴力查询时，如果当前修改数比询问的修改数少就把没修改的进行修改，反之回退。

需要注意的是，修改分为两部分：

1.若修改的位置在当前区间内，需要更新答案（del原颜色，add修改后的颜色）。

2.无论修改的位置是否在当前区间内，都要进行修改（以供add和del函数在以后更新答案）。

核心代码：

while (l<b[i].l) del(l++);
while (l>b[i].l) add(--l);
while (r<b[i].r) add(++r);
while (r>b[i].r) del(r--);
while (tt<b[i].time) change(i,++tt);
while (tt>b[i].time) change(i,tt--);
ans[b[i].id]=cnt;

复杂度：

用$B$表示块的大小，$ccnt$代表修改次数，$qcnt$代表询问次数，$tt$代表当前的时间点，$l块$代表以左端点分的块，$r块$代表以右端点分的块。

对于指针$l$，在同一$l块$内每次最多移动$B$，跨$l块$块每次最多移动$2B$，总移动次数为$O(qcnt×B)$。

对于指针$r$，在同一$l块$块内，且在同一$r块$内，每次最多移动$B$，跨$r块$块每次最多移动$2B$，总移动次数为$O(qcnt×B)$；在跨$l块$块内，每次最多移动$n$，总移动次数为$O(n×frac{n^2}{B})$。所以最终总的移动次数为$O(qcnt×B+n×frac{n^2}{B})$。

对于时间指针$tt$，对于每个$r块$，最坏情况下移动$ccnt$次，总共有$(frac{n}{B})^2$个$r块$，所以总的移动次数为$frac{ccnt×n^2}{B^2}$。

所以总的移动次数为：$O(qcnt×B+n×frac{n^2}{B}+frac{ccnt×n^2}{B^2})$。

对于题目中，$qcnt$与$ccnt$的个数未知，都用$m$来表示，所以总的移动次数为：$O(m×B+n×frac{n^2}{B}+frac{mn^2}{B^2})$。

$B$的最佳取值为：。

当$n==m$时，总的移动次数为：$O(n×B+n×frac{n^2}{B}+frac{n^3}{B^2})$，当$B=n^frac{2}{3}$时，取得最小值$O(n^frac{5}{3})$。

所以，带修莫队的时间复杂度为$O(nlogn+n^frac{5}{3})$。

例.洛谷1903[国家集训队]数颜色 / 维护队列

传送：https://www.luogu.org/problemnew/show/P1903

题意：n个物品，每个物品有一个颜色，m个操作。操作1：询问$[l,r]$内不同颜色的个数；操作2：将位置x的颜色修改为tmp。

分析：带修莫队模板。

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e4+10;
const int maxnum=1e6+5;
struct node{
    int l,r,id,time,lblo,rblo;
    bool operator <(node p)const{
        return lblo<p.lblo || lblo==p.lblo && rblo<p.rblo 
            || lblo==p.lblo && rblo==p.rblo && time<p.time;
    }
}b[maxn];
struct node2{
    int x,tmp;
}c[maxn];
int num[maxnum],ans[maxn],a[maxn];
int l,r,cnt,qcnt,ccnt,tt,block;
void add(int x){
    int tmp=a[x];
    if (num[tmp]==0) cnt++;
    num[tmp]++;
}
void del(int x){
    int tmp=a[x];
    if (num[tmp]==1) cnt--;
    num[tmp]--;
}
void change(int i,int tt){
    if (c[tt].x>=b[i].l && c[tt].x<=b[i].r){
        //删除颜色 
        if (num[a[c[tt].x]]==1) cnt--;
        num[a[c[tt].x]]--;
        //添加颜色
        if (num[c[tt].tmp]==0) cnt++;
        num[c[tt].tmp]++; 
    }
    swap(a[c[tt].x],c[tt].tmp);  //回退 
}
int main(){
    int n,m; scanf("%d%d",&n,&m);
    block=pow(n,2.0/3);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    qcnt=0,ccnt=0; char ss[10];
    for (int i=0;i<m;i++){
        scanf("%s",ss);
        if (ss[0]=='Q'){
            scanf("%d%d",&b[qcnt].l,&b[qcnt].r);
            b[qcnt].lblo=b[qcnt].l/block;
            b[qcnt].rblo=b[qcnt].r/block;
            b[qcnt].id=qcnt;
            b[qcnt++].time=ccnt;
        }
        else{
            ++ccnt;
            scanf("%d%d",&c[ccnt].x,&c[ccnt].tmp);
        }
    }
    sort(b,b+qcnt);
    memset(num,0,sizeof(num));
    l=1,r=0,cnt=0,tt=0;
    for (int i=0;i<qcnt;i++){
        while (l<b[i].l) del(l++);
        while (l>b[i].l) add(--l);
        while (r<b[i].r) add(++r);
        while (r>b[i].r) del(r--);
        while (tt<b[i].time) change(i,++tt);
        while (tt>b[i].time) change(i,tt--);
        ans[b[i].id]=cnt;
    }
    for (int i=0;i<qcnt;i++) printf("%d
",ans[i]);
    return 0;
}

3.树上莫队

（小哲先去学LCA了！

算法介绍：

树上莫队，顾名思义，就是将莫队由序列挪至树上。

首先需要了解，LCA以及欧拉序（转）。

• 欧拉序：

核心思想是：当访问到点$i$时，加入序列，然后访问$i$的子树，当访问完时，再把$i$加入序列。

对于上图这棵树的欧拉序为：1 2 3 4 4 5 5 6 6 3 7 7 2 1

• LCA：

表示树上两结点之间的最近公共祖先。

 

树上莫队所求解的最经典（基础）问题为：求解树上$x$到$y$的唯一路径上出现了多少个不同的数。

这里设$st[i]$代表访问$i$时加入欧拉序的时间，$ed[i]$代表回溯经过$i$时加入欧拉序的时间。

假设：$st[x]<st[y]$，即先访问$x$，再访问$y$。

下面分情况讨论：

1.若$lca(x,y)=x$，这个时候代表$x,y$在同一条链上，那么在$st[x]$到$st[y]$的这段区间中，有的点经过了两次，有的点没有经过，这些点对答案没有贡献，只需要统计那些经过一次的点就可以了。

比如询问$2,6$时，$(st[2],st[6])=2 3 4 4 5 5 6$，4和5都出现了两次，不计入答案。

2.若$lca(x,y) epx$时，这个时候代表$x,y$在不同的子树里，同样按照上面的方法统计$ed[x]$到$st[y]$这段区间内的点就好。

比如询问$4,7$时，$(ed[4],et[7])=4 5 5 6 6 3 7$。

综上所述，我们需要特判两点之间的$lca$。

带修树上莫队

上面是不带修改的树上莫队。

带单点修改的树上莫队。

参考博客：https://www.cnblogs.com/ouuan/p/MoDuiTutorial.html

复杂度：

块的大小在$[B,3B)$，所以两点间的路径长度也在$[B,3B)$，块内移动是$O(B)$的。编号相邻的块位置相邻，之间路径长度也为$O(B)$。然后就与序列莫队一样。

例1。洛谷4618[SDOI2018]原题识别

传送：https://www.luogu.org/problemnew/show/P4618

题意：给定一个$n$个节点的树，每个节点表示一个整数，$m$个询问，问$u$到$v$的路径上有多少个不同的整数。

分析：树上莫队模板。

（辣鸡题目。。没有给$a[i]$范围，是$leq10^9$。需要把结点权值离散化再做。

#include<bits/stdc++.h>
using namespace std;
const int maxn=4e5+10;
typedef pair<int,int> pii; 
vector<int> mp[maxn];
vector<pii> q[maxn];
map<int,int> mp_;
int block,tot,num_,kk,cnt,ll,rr;
int ans[maxn],vis[maxn],fa[maxn],num[maxn],p[maxn];
int st[maxn],ed[maxn],sta[maxn],bel[maxn],a[maxn],bb[maxn];
struct node{
    int x,y,lca,blo,id;
    bool operator <(node b)const {
        return blo<b.blo || blo==b.blo && st[y]<st[b.y];
    }
}b[maxn];
void dfs(int xx,int pre){
    st[xx]=++tot; p[tot]=xx;
    int now=num_;
    for (int i=0;i<mp[xx].size();i++){
        int tmp=mp[xx][i];
        if (tmp==pre) continue;
        dfs(tmp,xx);
        if (num_-now>=block){
            kk++;
            while (num_!=now) bel[sta[num_--]]=kk;
        } 
    }
    sta[++num_]=xx;   //入栈
    ed[xx]=++tot; p[tot]=xx; 
}
int find(int x){
    if (fa[x]==x) return x;
    else return fa[x]=find(fa[x]);
}
void LCA(int root){
    fa[root]=root;
    vis[root]=1;
    for (int i=0;i<mp[root].size();i++){
        int tmp=mp[root][i];
        if (vis[tmp]) continue;
        LCA(tmp);
        fa[tmp]=root;
    }
    for (int i=0;i<q[root].size();i++){
        pii tmp=q[root][i];
        if (vis[tmp.first]){
            b[tmp.second].lca=find(tmp.first);
        }
    }
}
void add(int x){
    int tmp=a[x];
    num[tmp]++;
    if (num[tmp]==1) cnt++;
} 
void del(int x){
    int tmp=a[x];
    num[tmp]--;
    if (num[tmp]==0) cnt--;
} 
void update(int x){
    if (vis[x]) del(x); else add(x);
    vis[x]^=1;
}
int main(){
    int n,m,x,y,l,r; scanf("%d%d",&n,&m);
    block=sqrt(n);
    for (int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        bb[i]=a[i];
    }
    sort(bb+1,bb+1+n);
    int kk=unique(bb+1,bb+1+n)-(bb+1);
    for (int i=1;i<=kk;i++) mp_[bb[i]]=i;
    for (int i=1;i<=n;i++) a[i]=mp_[a[i]];  //离散化 
    
    for (int i=0;i<n-1;i++){
        scanf("%d%d",&x,&y);
        mp[x].push_back(y);
        mp[y].push_back(x);
    } 
    tot=0; num_=0; kk=0;
    dfs(1,0);   //处理欧拉序 
    while (num_) bel[sta[num_--]]=kk;
    //for (int i=1;i<=tot;i++) cout << p[i] << "  "; cout << endl;
    
    for (int i=0;i<m;i++){
        scanf("%d%d",&b[i].x,&b[i].y);
        if (st[b[i].x]>st[b[i].y]) swap(b[i].x,b[i].y);
        b[i].blo=bel[b[i].x]; b[i].id=i;
        q[b[i].x].push_back({b[i].y,i});
        q[b[i].y].push_back({b[i].x,i});
    } 
    memset(vis,0,sizeof(vis));
    LCA(1); 
    
    //莫队 
    sort(b,b+m);
    ll=1,rr=0,cnt=0;
    memset(num,0,sizeof(num));
    memset(vis,0,sizeof(vis));
    for (int i=0;i<m;i++){
        //cout << b[i].x << "  " << b[i].y << endl;
        int kk=b[i].lca;
        if (kk==b[i].x){l=st[b[i].x]; r=st[b[i].y];}
        else{l=ed[b[i].x]; r=st[b[i].y];}
        //cout << l <<" " << r << endl;
        while (ll<l) update(p[ll++]); 
        while (ll>l) update(p[--ll]);
        while (rr<r) update(p[++rr]);
        while (rr>r) update(p[rr--]);
        if(kk!=b[i].x) update(kk);
        ans[b[i].id]=cnt;
        if(kk!=b[i].x) update(kk);
    }
    for (int i=0;i<m;i++) printf("%d
",ans[i]);
    return 0;
} 

 例2。洛谷4074[WC2013]糖果公园

传送：https://www.luogu.org/problemnew/show/P4074

题意：给出一颗n个结点的树，每个结点上有一种糖果（糖果种类是$[q,m]$）；

一个人经过结点$i$品尝糖果j获得的愉悦度为$w[time[j]]*val[j]$  (其中$time[j]$指$j$的品尝次数)；

给出$q$次操作，操作有两种：1.更改某结点的糖果种类；2.查询某两个结点路径上的愉悦度总和。

分析：单点修改树上莫队。