莫队 - 例题+练习

最新推荐文章于 2025-02-22 16:59:44 发布
原创 最新推荐文章于 2025-02-22 16:59:44 发布 · 254 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

lyw姐姐放假回来给我们讲课
比zgs好

莫队基础

分块降时间复杂度
把区间之间的转化优化为求一个曼哈顿距离 ( ∣ l 1 − l 2 ∣ + ∣ r 1 − r 2 ∣ ) (|l_1-l_2|+|r_1-r_2|) (∣l1​−l2​∣+∣r1​−r2​∣)
再优化这个曼哈顿距离——利用分块
即以L所在的块为第一关键字，R第二关键字排序

莫队要求离线

HH的项链
code

//莫队过不去 
#include<bits/stdc++.h>
using namespace std;
#define in Read()
#define re register
const int LEN=1e6+10;
int n,m,size;
int line[LEN];
struct node{
	int l,r,i,p,ans;
}quary[LEN];
int cnt[LEN];
int ans;

inline int in{
	int i=0,f=1;char ch;
	while((ch>'9'||ch<'0')&&ch!='-')ch=getchar();
	if(ch=='-')ch=getchar(),f=-1;
	while(ch>='0'&&ch<='9')i=(i<<1)+(i<<3)+ch-48,ch=getchar();
	return i*f;
}

inline bool comp(const node &a,const node &b){
	if(a.p!=b.p)return a.p<b.p;
	return a.r<b.r;
}

inline bool comp_for_back(const node &a,const node &b){
	return a.i<b.i;
}

inline void Write(const int &a){
    int x=a;
    if(x<0){
        putchar('-');
        x=-x;
    }
    static short buf[20];
    short tot=0;
    do{
        buf[tot++]=x%10;
        x/=10;
    }while(x);
    while(tot)putchar(buf[--tot]+'0');
}

int main(){
	n=in;
	size=(int)sqrt(n);
	for(re int i=1;i<=n;i++)line[i]=in;
	m=in;
	for(re int i=1;i<=m;i++){
		quary[i].l=in;
		quary[i].r=in;
		quary[i].i=i;
		quary[i].p=(quary[i].l-1)/size+1;
	}
	
	sort(quary+1,quary+m+1,comp);
	
	ans=0;
	int l=1,r=0;
	for(re int i=1;i<=m;i++){
		
		while(r<quary[i].r){
			r++;
			if(!cnt[line[r]])ans++;
			cnt[line[r]]++;
		}
		while(r>quary[i].r){
			cnt[line[r]]--;
			if(!cnt[line[r]])ans--;
			r--;
		}
		while(l<quary[i].l){
			cnt[line[l]]--;
			if(!cnt[line[l]])ans--;
			l++;
		}
		while(l>quary[i].l){
			l--;
			if(!cnt[line[l]])ans++;
			cnt[line[l]]++;
		}
		
		quary[i].ans=ans;
	}
	
	sort(quary+1,quary+m+1,comp_for_back);
	
	for(re int i=1;i<=m;i++)Write(quary[i].ans),putchar('\n');
	return 0;
}

别去络谷，会T（用线段树就行了，可惜我还没把它搞熟嘤嘤嘤~）

练习：BZOJ 2038 3781
（提高）3289 3809 4540

BZOJ2038

莫队需要特别注意的点在于移动l，r指针的时候各种量之间的关系：加减关系，包含关系等

#include<bits/stdc++.h>
#define in Read()
#define re register
#define int long long
inline int in{
	int i=0,f=1;char ch;
	while((ch>'9'||ch<'0')&&ch!='-')ch=getchar();
	if(ch=='-')f=-1,ch=getchar();
	while(ch<='9'&&ch>='0')i=(i<<1)+(i<<3)+ch-48,ch=getchar();
	return i*f;
}

const int NNN=5e4+10;
int n,m,c[NNN],size;
int r,l,cnt[NNN];
struct fraction{
	int nume,deno;
};
struct node{
	int l,r,i,p;
	fraction ans;
}query[NNN];

inline int gcd(int x,int y){
	if(x%y==0)return y;
	return gcd(y,x%y);
}

inline fraction frac(int nume/*分子*/,int deno/*分母:输进来r-l+1*/){
	fraction ans;
	//特判
	if(!nume){
		ans.nume=0,ans.deno=1;
		return ans;
	}
	
	//把分母调对 
	if(deno%2)deno=(deno-1)/2*deno;
	else deno=(deno/2)*(deno-1);
	
	int div=gcd(nume,deno);
	nume=nume/div;
	deno=deno/div;
	ans.nume=nume;
	ans.deno=deno;
	return ans;
}

inline bool comp(const node &a,const node &b){
	if(a.p!=b.p)return a.p<b.p;
	return a.r<b.r;
}

inline bool back(const node &a,const node &b){
	return a.i<b.i;
}

signed main(){
	n=in,m=in;
	size=(int)sqrt(n);
	for(re int i=1;i<=n;++i)c[i]=in;
	for(re int i=1;i<=m;++i){
		query[i].l=in;
		query[i].r=in;
		query[i].i=i;
		query[i].p=(query[i].l-1)/size;
	}
	
	std::sort(query+1,query+m+1,comp);
	
	int ans=0;
	l=1,r=0;
	for(re int i=1;i<=m;++i){
		
		while(r<query[i].r){
			++r;
			ans+=cnt[c[r]];
			++cnt[c[r]];
		}
		while(r>query[i].r){
			--cnt[c[r]];
			ans-=cnt[c[r]];
			--r;
		}
		while(l>query[i].l){
			--l;
			ans+=cnt[c[l]];
			++cnt[c[l]];
		}
		while(l<query[i].l){
			--cnt[c[l]];
			ans-=cnt[c[l]];
			++l;
		}
		
		query[i].ans=frac(ans,query[i].r-query[i].l+1);
	}
	
	std::sort(query+1,query+m+1,back);
	
	for(re int i=1;i<=m;++i)
		printf("%lld/%lld\n",query[i].ans.nume,query[i].ans.deno);
	
	return 0;
}

BZOJ3781

（很明显BZOJ并不想让你做这道题，那么全能的络谷就可以出马了）
这道题非常尴尬
我又在它上面浪费了1小时
在调试的时候遇到了一个非常日龙的情况：
在这里插入图片描述
然后
在这里插入图片描述
大草

最后发现MLE了

code

#include<bits/stdc++.h>
#define in Read()
#define re register
#define int long long
inline int in{
	int i=0,f=1;char ch;
	while((ch>'9'||ch<'0')&&ch!='-')ch=getchar();
	if(ch=='-')f=-1,ch=getchar();
	while(ch<='9'&&ch>='0')i=(i<<1)+(i<<3)+ch-48,ch=getchar();
	return i*f;
}

const int NNN=5e4+10;
int n,m,k;
int a[NNN],cnt[NNN];
int l=1,r;
int ans;
struct node{
	int l,r,i,p;
	int ans;
}query[NNN];

inline int sqare(int x){return x*x;}

inline void INIT(){
	n=in,m=in,k=in;
	int size=(int)std::sqrt(n);
	for(re int i=1;i<=n;++i)a[i]=in;
	for(re int i=1;i<=m;++i){
		query[i].l=in;
		query[i].r=in;
		query[i].i=i;
		query[i].p=(query[i].l-1)/size;
	}
}

inline bool comp(const node &a,const node &b){return (a.p!=b.p)?a.p<b.p:a.r<b.r;}
inline bool back(const node &a,const node &b){return a.i<b.i;}

inline void solve(){
	for(re int i=1;i<=m;++i){
		
		while(r<query[i].r){
			++r;
			ans+=2*cnt[a[r]]+1;
			++cnt[a[r]];
		}
		while(r>query[i].r){
			ans-=2*cnt[a[r]]-1;
			--cnt[a[r]];
			--r;
		}
		while(l<query[i].l){
			ans-=2*cnt[a[l]]-1;
			--cnt[a[l]];
			++l;
		}
		while(l>query[i].l){
			--l;
			ans+=2*cnt[a[l]]+1;
			++cnt[a[l]];
		}
		
		query[i].ans=ans;
		
	}
}

signed main(){
	INIT();
	std::sort(query+1,query+m+1,comp);
	solve();
	std::sort(query+1,query+m+1,back);
	for(re int i=1;i<=m;++i){
		printf("%lld\n",query[i].ans);
	}
	return 0;
}

BZOJ3289

莫队+树状数组求逆序对
（求逆序对：冒泡O(N2)，归并O(NlogN+代码难giao)，树状数组O(NlogN)）

#include<bits/stdc++.h>
#define in Read()
#define re register
inline int in{
	int i=0,f=1;char ch;
	while((ch>'9'||ch<'0')&&ch!='-')ch=getchar();
	if(ch=='-')f=-1,ch=getchar();
	while(ch<='9'&&ch>='0')i=(i<<1)+(i<<3)+ch-48,ch=getchar();
	return i*f;
}

const int NNN=5e4+10;
int a[NNN],block;
struct node{
	int l,r,i,ans,p;
	inline void get_query(int _i){
		l=in,r=in,i=_i,p=(l-1)/block;//细节 
	}
}query[NNN];
int tree[NNN];
int n,q;
int disc[NNN];

inline bool comp(const node &u,const node &v){
	return (u.p!=v.p)?u.p<v.p:u.r<v.r;
}

inline bool back(const node &u,const node &v){
	return u.i<v.i;
}

inline int lowbit(int i){
	return i&(-i);
}

inline void Add(int x,int pos){
	while(x<=n){
		tree[x]+=pos;
		x+=lowbit(x);
	}
}

inline int Query(int x){
	unsigned int sum=0;
	while(x>0){
		sum+=tree[x];
		x-=lowbit(x);
	}
	return sum;
}

inline void SOLVE(){
	int l=1,r=0,ans=0;
	std::sort(query+1,query+q+1,comp);
	for(re int i=1;i<=q;++i){
		while(r<query[i].r){
			++r;
			Add(a[r],1);
			ans+=r-l+1-Query(a[r]);
		}
		while(r>query[i].r){
			Add(a[r],-1);
			ans-=r-l-Query(a[r]);
			--r;
		}
		while(l<query[i].l){
			Add(a[l],-1);
			ans-=Query(a[l]-1);
			++l;
		}
		while(l>query[i].l){
			--l;
			Add(a[l],1);
			ans+=Query(a[l]-1);
		}
		query[i].ans=ans;
	}
	std::sort(query+1,query+q+1,back);
}

int main(){
	n=in;
	block=(int)std::sqrt(n);
	for(re int i=1;i<=n;++i)disc[i]=a[i]=in;
	std::sort(disc+1,disc+n+1);
	for(re int i=1;i<=n;++i)a[i]=std::lower_bound(disc+1,disc+n+1,a[i])-disc;
	q=in;
	for(re int i=1;i<=q;++i)query[i].get_query(i);
	SOLVE();
	for(re int i=1;i<=q;++i)printf("%d\n",query[i].ans);
	return 0;
}

解释一下移动左右指针的地方

树状数组，Query(x)返回的是x到0所有点的和
每个点为权值表示的话，返回的就是存在于数组的、小于x的数字个数
每次改变一个点，就要计算生成或消失的逆序对个数

对于一个按照下标依次+1来加入的序列它的逆序对个数N要这样算：

Add
ans+=i-Query(i)

把这个结论应用到本题上：
每移动一个指针，加入或者消除树状数组中该点，然后计算

  1. r++
    元素入树
    总共r-l+1个数，比a[r]小的有Query个（可以算自己：最后r-l+1加的那个1是可以把加进去的自己去掉的，后面l是另一种算法，没有算自己的，因为不好确定l是否在树状数组里面）
    新增了r-l+1-Query个逆序对
  2. r–
    元素出树
    总共r-l个数(r–把出树的去掉了)，比a[r]小的有Query个
    减少了r-l-Query个逆序对
  3. l++
    元素出树
    总共r-l个数，比a[l]小的有Query(a[l]-1)个（前缀和思想，不要吧自己包含进去了）
    减少了Query(a[l]-1)个
  4. l–
    元素入树
    总共r-l个数，比a[l]小的有Query(a[l]-1)个（前缀和思想）
    增加了Query(a[l]-1)个

注意再加点的时候加的是文件大小（a数组）

【算法笔记】莫队算法入门
luhaoren2009的博客
08-09 437
本来想学完回滚莫队、树上莫队、二离莫队之后一起写一个博客，但是一直学不会/kk，只好把已会的普通莫队和带修莫队写了（以后会补上的）
莫队算法 （普通莫队、带修莫队、树上莫队）
Josh_Shu_的博客
11-15 950
莫队算法
莫队算法讲解及例题
最新发布
STY_fish_2012的博客
02-22 1068
对于区间查询数字出现次数的问题，我们可以使用莫队。比如，当询问区间是1n时，可以通过ON的复杂度解决。那接下来再询问2n或者1n−1时，就可以通过O1的复杂度解决这个询问。所以，当有m个询问的时候，我们就可以根据第i个询问的结果推出第i1个询问的结果。这样就不用每一次询问都用ON去跑了。于是就产生了优化版：对左端点进行排序。所以我们就可以对左端点进行分块（后面发文章讲）经过，可以得出每个块大小设为n​时，可以使时间复杂度最优。
基础莫队例题
weixin_45724872的博客
11-16 739
引入 看了很多篇解释，我个人理解是莫队是优化后的双指针算法； 比如说我们现在要维护区间内数字出现的次数； 从[A,B][A,B][A,B]区间转移到[C,D][C,D][C,D]区间； 对于BBB到DDD的过程，就是不断的新增数字，如果这个数字的种类是第一次出现，那么就++ans； 对于AAA到CCC的过程，就是不断的减少数字，如果这个数字出现的次数已经归零了，那么就--ans； 以上的转移可以做到 但是现在我们的询问是乱序的，那么我们可以将所有的询问存下来，并且排个序； 为了使得时间复杂度降低到O
莫队经典例题
liaoxiyan123的博客
09-19 379
传送门:[AHOI2013]作业 本题做法:莫队+分块(辅助). 1用莫队统计区间内每个数的个数以及所在块中数的个数和种类数. 2.分块按照值域分,整块直接加上处理后的区间的相关数据,碎块暴力枚举并统计在范围内的数. 具体看代码: #include<bits/stdc++.h> #define N 100005 #define in read() #define re register using namespace std; int n,m,l,r,block; int a[N],zhi,f
【模版】莫队（带修改莫队、树上莫队）算法
LH_991215的博客
07-07 1930
莫队算法 莫队算法是 离线 解决 区间查询 问题的一种高效暴力算法。 前置知识点：①①①分块 ②②② sortsortsort关键字排序 ③③③ lcalcalca查询(树上莫队) 时间复杂度：O(n∗n)O(n*\sqrt{n})O(n∗n​) 空间复杂度：O(n∗n)O(n*\sqrt{n})O(n∗n​) 算法流程： 一、确定分块大小：每块大小为 n\sqrt{n}n​ 。确定每个元素属于哪一块。 二、用结构体存储询问并用 sortsortsort 排序： 对于每次询问的 左端点 lll，按照 .
莫队算法——从入门到黑题
weixin_30512043的博客
12-14 2107
众所周知，莫队是由莫涛大神提出的，一种玄学毒瘤暴力骗分区间操作算法，它以简短的框架、简单易记的板子和优秀的复杂度闻名于世。然而由于莫队算法应用的毒瘤，很多可做的莫队模板题都有着较高的难度评级，令很多初学者望而却步。然而，如果你真正理解了莫队的算法原理，那么它用起来还是很简单的。当然某些套左套右的毒瘤除外 0、前置芝士： 莫队算法还是比较独立的。不过你还是得了解了解以下的一些知识： \(1\)、分...
【算法笔记】莫队算法（基础莫队，带修莫队，回滚莫队，树上莫队，二次离线莫队）
繁凡さん的博客
11-23 7505
来这里学习莫队以及神奇的证明：莫队算法 --算法竞赛专题解析（26） 我们首先考虑双指针的暴力法，发现很容易就会被卡成O(nm)O(nm)O(nm)，这时候我们的莫队出现了，莫队说，我可以像变魔术一样，把O(nm)O(nm)O(nm)的算法通过一个神奇的排序方式，使得我们最坏的情况下，时间复杂度也会非常优秀：O(nn)O(n\sqrt{n})O(nn​)。 莫队算法是一个离线的算法，我们先将所有的询问全部存下来，然后排序。我们的每一个询问都是一个左右区间，(l,r)(l ,r)(l,r) 我们的排序方法为双
莫队细讲——从零开始学莫队
hyf_juruo的博客
05-29 3646
莫队算法 参考资料：https://www.cnblogs.com/WAMonster/p/10118934.html 不得不说，上面那篇写得实在太好了 前言——引入 关于莫队算法发明者——莫队·莫涛 众所周知，OIer常用“*队”来称呼实力强大的选手，就如：李队，刘队，杨队，何队 %%%%% 这位莫队，实在是太强了： 【NOI2009】 577577577 全国Rk1 ；前国家队队长 OrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrzOrz
莫队算法学习笔记+例题
qq_43710979的博客
05-18 255
莫队算法是用来解决离线区间问题的暴力解法，但是这种暴力解法是经过分块优化的，朴素暴力解法的时间复杂度是O(n*m)，而莫队算法的复杂度一般来说就是O(n*sqrt(m))。莫队算法的核心，我的理解就是相邻区间状态的转移，前提是状态的转移计算时间必须要是O(1)，否则的话就会出现复杂度爆炸。比如现在知道了区间[L, R]的解，那么如果要使用莫队算法，必须要在O(1)的时间复杂度下分别计算出区间[L-...
莫队练习题
蒲公英殇的博客
09-06 407
莫队刷题
超全的莫队算法一遍过
GROZAX的博客
04-10 8922
莫队的基本思想、回滚莫队、树上莫队、二次离线，一文搞定。什么？你还不会莫队？看完这篇文章你就会了
莫队算法总结&专题训练2
Plozia 的小窝
12-09 407
上回我们在莫队算法总结&专题训练1讲解了莫队的一般套路以及各种优化方式，但那只是基础，接下来将会介绍莫队更多的用法。 3.练习题 题单： 普通练手题 CF220B Little Elephant and Array P2709 小 B 的询问 P1494 [国家集训队]小 Z 的袜子 带修莫队 P1903 [国家集训队]数颜色 / 维护队列 树上莫队 SP10707 COT2 - Count on a tree II 树上带修莫队 P4074 [WC2013]糖果公园 回滚莫队/不删除莫队 P59
莫队算法+练习题题解+快读
wuxiaowu547的博客
07-21 565
自己开的练习赛：（三个模板题） https://vjudge.net/contest/239597#problem 莫队算法：给定一个区间（l,r）的结果，求问（l+1,r）,(l,r+1),(l-1,r)(l,r-1); 核心： 一个修改函数；(先减去之前的，挪到现在的位置，加上现在的） 四个while; （先更新，再挪L）； 模板： #include&lt;...
莫队总结 莫队例题
hutwuguangrong的博客
05-14 483
普通莫队 假设我们已知区间 l,r，需要计算的区间为 L,R，由于l 和 r分别只能单步转移，所以需要的时间复杂度为| L-l |+|R-r|。相当于把两个区间分别看成是平面上的两个整点p1(l,r)和p2(L,R)两点之间的转移开销为两点之间的曼哈顿距离。连接所有点的最优方案为一棵树，那么整体的时间复杂度就是这棵树上所有曼哈顿距离之和。 于是乎最优的复杂度肯定是这棵树是最小生成树的时候...
专题训练3 莫队算法题目清单
qq_39898877的博客
09-20 647
bzoj 2048(入门) 题解：https://blog.csdn.net/qq_39898877/article/details/82807192 hdu 4467 题解：https://blog.csdn.net/qq_39898877/article/details/82840862 hdu 4638 题解：https://blog.csdn.net/qq_39898877/ar...
普通、带修(可持久化)莫队算法入门例题详解
菜鸡成长史
05-24 831
目录 【莫队算法】 【普通莫队】 【代码】 【题面】 【带修莫队】 【代码】 【题面】 【总结】 【莫队算法】 参考大米饼的莫队算法，目前的题型概括为三种：普通莫队，带修莫队以及树形莫队。 【普通莫队】 例题：2038: [2009国家集训队]小Z的袜子(hose) 题意：给定编号1-n的n只袜子的颜色，输出从询问的区间[L,R]中随机抽出两只袜子颜色相同的概率。...
莫队算法例题codeforces617E
路漫漫其修远兮，吾将上下而求索
07-24 546
XOR and Favorite Number time limit per test 4 seconds memory limit per...
【莫队算法】的小例题
cyclization的小栈
04-09 839
【BZOJ 2038】【2009 国家集训队】具体来说，小Z把这N只袜子从1到N编号，然后从编号L到R(L 尽管小Z并不在意两只袜子是不是完整的一双，甚至不在意两只袜子是否一左一右，他却很在意袜子的颜色，毕竟穿两只不同色的袜子会很尴尬。 你的任务便是告诉小Z，他有多大的概率抽到两只颜色相同的袜子。当然，小Z希望这个概率尽量高，所以他可能会询问多个(L,R)以方便自己选择。 【题解】 对于L,R
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值