莫队算法总结

最新推荐文章于 2024-11-26 21:15:03 发布
最新推荐文章于 2024-11-26 21:15:03 发布
阅读量466 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 莫队算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ACpartner/article/details/75998670

       莫队算法主要是利用了曼哈顿距离的长度关系，将每一个询问的坐标抽象为一个点，然后将询问分块，进行排序（分块的原因是使得这些询问坐标的移动的曼哈顿距离达到 最小），排序之后再按照此时的顺序进行左右区间的移动，而在内部的实现的过程就要看各个题目的要求了，所以在这里主要是理解到，莫队算法的核心是：平面上移动曼哈顿距离最小 （利用分块求得平面上曼哈顿距离的最小生成树）+ 离线查询（无法在线查询），在解题的过程中也要想到使得每一次转移计算答案的时间也要是O（1）的，到此，莫队算法也就完成。

三个样例：

HH的项链

（询问区间内不同数的个数，temp记录答案，只要num[arr[x]]>0那么temp+=1）

HYSBZ oj 1878

HH有一串由各种漂亮的贝壳组成的项链。HH相信不同的贝壳会带来好运，所以每次散步 完后，他都会随意取出一
段贝壳，思考它们所表达的含义。HH不断地收集新的贝壳，因此他的项链变得越来越长。有一天，他突然提出了一
个问题：某一段贝壳中，包含了多少种不同的贝壳？这个问题很难回答。。。因为项链实在是太长了。于是，他只
好求助睿智的你，来解决这个问题。
Input
第一行：一个整数N，表示项链的长度。 
第二行：N个整数，表示依次表示项链中贝壳的编号（编号为0到1000000之间的整数）。 
第三行：一个整数M，表示HH询问的个数。 
接下来M行：每行两个整数，L和R（1 ≤ L ≤ R ≤ N），表示询问的区间。
N ≤ 50000，M ≤ 200000。
Output

M行，每行一个整数，依次表示询问对应的答案。

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

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#define siz 50005

using namespace std;
struct Query{
    int L,R,id;
}node[siz*4];
int arr[siz],ans[siz*4],num[siz*20];
int n,m,unit;
bool cmp(Query a,Query b){
    if(a.L/unit!=b.L/unit) return a.L/unit<b.L/unit;
    return a.R<b.R;
}
void solve(){
    int temp=0;
    memset(num,0,sizeof(num));
    int L=1,R=0;
    for(int i=0;i<m;i++){
       /// cout<<node[i].L<<" "<<node[i].R<<endl;
        while(R<node[i].R){
            R++;
            if(num[arr[R]]!=0)
            temp-=1;
            num[arr[R]]++;
            if(num[arr[R]]!=0)
            temp+=1;
           // cout<<arr[R]<<"---111---"<<num[arr[R]]<<endl;
        }
        while(R>node[i].R){
            //R++;
            if(num[arr[R]]!=0)
            temp-=1;
            num[arr[R]]--;
            if(num[arr[R]]!=0)
            temp+=1;
          //  cout<<arr[R]<<"---222---"<<num[arr[R]]<<endl;
            --R;

        }
        while(L<node[i].L){
           /// R++;
           if(num[arr[L]]!=0)
            temp-=1;
            num[arr[L]]--;
            if(num[arr[L]]!=0)
            temp+=1;
            //cout<<arr[L]<<"---333---"<<num[arr[L]]<<endl;
            L++;
        }
        while(L>node[i].L){
            L--;
            if(num[arr[L]]!=0)
            temp-=1;
            num[arr[L]]++;
            if(num[arr[L]]!=0)
            temp+=1;
           // cout<<arr[L]<<"---444---"<<num[arr[L]]<<endl;
        }
        ans[node[i].id]=temp;
    }
    //cout<<temp<<endl;
    for(int i=0;i<m;i++){
        printf("%d\n",ans[i]);
    }
}
int main()
{
    while(~scanf("%d",&n)){
        for(int i=1;i<=n;i++){
            scanf("%d",&arr[i]);
        }
        unit=(int)sqrt(n);
        scanf("%d",&m);
        for(int i=0;i<m;i++){
            node[i].id=i;
            scanf("%d %d",&node[i].L,&node[i].R);
        }
        sort(node,node+m,cmp);
        solve();
    }
    return 0;
}

小Z的袜子(hose)

（邝斌巨巨模板，不解释了，用这道题学的 莫队算法，另外两道是自己写的）

作为一个生活散漫的人，小Z每天早上都要耗费很久从一堆五颜六色的袜子中找出一双来穿。终于有一天，小Z再也无法忍受这恼人的找袜子过程，于是他决定听天由命……
具体来说，小Z把这N只袜子从1到N编号，然后从编号L到R(L 尽管小Z并不在意两只袜子是不是完整的一双，甚至不在意两只袜子是否一左一右，他却很在意袜子的颜色，毕竟穿两只不同色的袜子会很尴尬。
你的任务便是告诉小Z，他有多大的概率抽到两只颜色相同的袜子。当然，小Z希望这个概率尽量高，所以他可能会询问多个(L,R)以方便自己选择。

Input

输入文件第一行包含两个正整数N和M。N为袜子的数量，M为小Z所提的询问的数量。接下来一行包含N个正整数Ci，其中Ci表示第i只袜子的颜色，相同的颜色用相同的数字表示。再接下来M行，每行两个正整数L，R表示一个询问。

Output

包含M行，对于每个询问在一行中输出分数A/B表示从该询问的区间[L,R]中随机抽出两只袜子颜色相同的概率。若该概率为0则输出0/1，否则输出的A/B必须为最简分数。（详见样例）

Sample Input 
6 4
1 2 3 3 3 2
2 6
1 3
3 5
1 6
Sample Output 
2/5
0/1
1/1
4/15
【样例解释】询问1：共C(5,2)=10种可能，其中抽出两个2有1种可能，抽出两个3有3种可能，概率为(1+3)/10=4/10=2/5。
询问2：共C(3,2)=3种可能，无法抽到颜色相同的袜子，概率为0/3=0/1。
询问3：共C(3,2)=3种可能，均为抽出两个3，概率为3/3=1/1。注：上述C(a, b)表示组合数，组合数C(a, b)等价于在a个不同的物品中选取b个的选取方案数。
【数据规模和约定】30%的数据中 N,M ≤ 5000；60%的数据中 N,M ≤ 25000；100%的数据中 N,M ≤ 50000，1 ≤ L < R ≤ N，Ci ≤ N。

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#define siz 50005
#define LL long long
using namespace std;
struct Query{
    int L,R,id;
}node[siz];
LL gcd(LL a,LL b){
    if(b==0) return a;
    else return gcd(b,a%b);
}
struct Ans{
    LL a,b;
    void reduce(){
        LL d=gcd(a,b);
        a/=d,b/=d;
    }
}ans[siz];

int a[siz],num[siz];
int n,m,unit;
bool cmp(Query a,Query b){
    if(a.L/unit!=b.L/unit) return a.L/unit<b.L/unit;
    else return a.R<b.R;
}
void work(){
    LL temp=0;
    memset(num,0,sizeof(num));
    int L=1,R=0;
    for(int i=0;i<m;i++){
        while(R<node[i].R){

            R++;
            //cout<<L<<"--111---"<<R<<endl;
            temp-=(LL) num[a[R]]*num[a[R]];
            num[a[R]]++;
            temp+=(LL) num[a[R]]*num[a[R]];
        }
        while(R>node[i].R){
            //R++;
            //cout<<L<<"--222---"<<R<<endl;
            temp-=(LL) num[a[R]]*num[a[R]];
            num[a[R]]--;
            temp+=(LL) num[a[R]]*num[a[R]];
            --R;
        }
        while(L<node[i].L){
            //L++;
           // cout<<L<<"---3----"<<R<<endl;
            temp-=(LL) num[a[L]]*num[a[L]];
            num[a[L]]--;
            temp+=(LL) num[a[L]]*num[a[L]];
            L++;
        }
        while(L>node[i].L){
            L--;
            //cout<<L<<"---444--"<<R<<endl;
            temp-=(LL) num[a[L]]*num[a[L]];
            num[a[L]]++;
            temp+=(LL) num[a[L]]*num[a[L]];
        }
        ans[node[i].id].a=temp-(R-L+1);
        ans[node[i].id].b=(LL) (R-L+1)*(R-L);
        ans[node[i].id].reduce();
    }
}
int main()
{
    while(~scanf("%d %d",&n,&m)){
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
        }
        for(int i=0;i<m;i++){
            node[i].id=i;
            scanf("%d%d",&node[i].L,&node[i].R);
        }
        unit=(int)sqrt(n);
        sort(node,node+m,cmp);
        for(int i=0;i<m;i++){
           // cout<<node[i].L<<" "<<node[i].R<<endl;
        }
        work();
        for(int i=0;i<m;i++){
            printf("%lld/%lld\n",ans[i].a,ans[i].b);
        }
    }
    return 0;
}

Sequence

csu 1515

(求区间内abs(a[i]-a[j])==1的个数，思路：num[arr[i]]记录arr[i]的个数，要使得abs(arr[i]-x==1),那么x=arr[i]-1||x=a[rr]+1,所以，temp+=num[arr[i]+1]||temp+=num[arr[i]+1],

但是，问题来了，arr[]数组是32位整数，数组最大只能 开到arr[10^8],那么现在就只能使用map了，将arr[]数组按照从小到大的顺序map,意思是如果arr[i]>arr[j]那么map[arr[i]]>map[arr[j]],map的 值是从1到n而n最大为10^4，绰绰有余了，到此，此题再加上莫队算法就能解决了。)

Give you a sequence consisted of n numbers. You are required to answer how many pairs of numbers (ai, aj) satisfy that | ai - aj | = 1 and L ≤ i < j ≤ R.

Input

The input consists of one or more test cases.
For each case, the first line contains two numbers n and m, which represent the length of the number sequence and the number of queries. ( 1 ≤ n ≤ 10^4, 1 ≤ m ≤ 10^5 )
The second line consists of n numbers separated by n - 1 spaces.( 0 ≤ ai < 2^31 )
Then the m lines followed each contain two values Li and Ri.

Output

For each case just output the answers in m lines.

Sample Input 
10 10
5 5 1 3 6 3 5 7 1 7
3 4
6 8
8 9
2 8
5 7
6 7
1 9
3 10
3 10
5 6
Sample Output 
0
0
0
3
1
0
4
3
3
0

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#define siz 10005
#include <algorithm>
#include <map>
using namespace std;
struct Query{
    int L,R,id;
}node[siz*10];
int ans[siz*10];
int arr[siz],num[siz],unit,trr[siz],Np;
map<int,int>Mp;
int n,m;
void _Init(){
    Mp.clear();
    for(int i=1;i<=n;i++){
        trr[i]=arr[i];
    }
    sort(trr+1,trr+1+n);
    Np=unique(trr+1,trr+1+n)-trr-1;
    for(int i=1;i<=Np;i++){
        Mp[trr[i]]=i;
       // cout<<Mp[trr[i]]<<"&&&"<<trr[i]<<endl;
    }
}
bool cmp(Query a,Query b){
    if(a.L/unit!=b.L/unit) return a.L/unit<b.L/unit;
    return a.R<b.R;
}
void  solve(){
    int temp=0;
    memset(num,0,sizeof(num));
    int L=1,R=0;
    int ant=-1;
    for(int i=0;i<m;i++){
        while(R<node[i].R){
            R++;
            if(trr[Mp[arr[R]]]-trr[Mp[arr[R]]-1]==1){
                temp-=num[Mp[arr[R]]]*num[Mp[arr[R]]-1];
            }
            if(trr[Mp[arr[R]]+1]-trr[Mp[arr[R]]]==1){
                temp-=num[Mp[arr[R]]]*num[Mp[arr[R]]+1];
            }

            num[Mp[arr[R]]]++;
            if(trr[Mp[arr[R]]]-trr[Mp[arr[R]]-1]==1){
                temp+=num[Mp[arr[R]]]*num[Mp[arr[R]]-1];
            }
            if(trr[Mp[arr[R]]+1]-trr[Mp[arr[R]]]==1){
                temp+=num[Mp[arr[R]]]*num[Mp[arr[R]]+1];
            }
        }
        while(R>node[i].R){
            if(trr[Mp[arr[R]]]-trr[Mp[arr[R]]-1]==1){
                temp-=num[Mp[arr[R]]]*num[Mp[arr[R]]-1];
            }
            if(trr[Mp[arr[R]]+1]-trr[Mp[arr[R]]]==1){
                temp-=num[Mp[arr[R]]]*num[Mp[arr[R]]+1];
            }
            num[Mp[arr[R]]]--;
            if(trr[Mp[arr[R]]]-trr[Mp[arr[R]]-1]==1){
                temp+=num[Mp[arr[R]]]*num[Mp[arr[R]]-1];
            }
            if(trr[Mp[arr[R]]+1]-trr[Mp[arr[R]]]==1){
                temp+=num[Mp[arr[R]]]*num[Mp[arr[R]]+1];
            }
            R--;
        }
        while(L<node[i].L){
            if(trr[Mp[arr[L]]+1]-trr[Mp[arr[L]]]==1){
                temp-=num[Mp[arr[L]]+1]*num[Mp[arr[L]]];
            }
            if(trr[Mp[arr[L]]]-trr[Mp[arr[L]]-1]==1){
                temp-=num[Mp[arr[L]]]*num[Mp[arr[L]]-1];
            }
            num[Mp[arr[L]]]--;
            if(trr[Mp[arr[L]]+1]-trr[Mp[arr[L]]]==1){
                temp+=num[Mp[arr[L]]+1]*num[Mp[arr[L]]];
            }
            if(trr[Mp[arr[L]]]-trr[Mp[arr[L]]-1]==1){
                temp+=num[Mp[arr[L]]]*num[Mp[arr[L]]-1];
            }
            L++;
        }
        while(L>node[i].L){
            L--;
            if(trr[Mp[arr[L]]+1]-trr[Mp[arr[L]]]==1){
                temp-=num[Mp[arr[L]]+1]*num[Mp[arr[L]]];
            }
            if(trr[Mp[arr[L]]]-trr[Mp[arr[L]]-1]==1){
                temp-=num[Mp[arr[L]]]*num[Mp[arr[L]]-1];
            }
            num[Mp[arr[L]]]++;
            if(trr[Mp[arr[L]]+1]-trr[Mp[arr[L]]]==1){
                temp+=num[Mp[arr[L]]+1]*num[Mp[arr[L]]];
            }
            if(trr[Mp[arr[L]]]-trr[Mp[arr[L]]-1]==1){
                temp+=num[Mp[arr[L]]]*num[Mp[arr[L]]-1];
            }
        }
        ans[node[i].id]=temp;
    }
    for(int i=0;i<m;i++){
        printf("%d\n",ans[i]);
    }
}
int main()
{
    while(~scanf("%d%d",&n,&m)){
        for(int i=1;i<=n;i++){
            scanf("%d",&arr[i]);
        }
        _Init();
        unit=(int)sqrt(n);
        for(int i=0;i<m;i++){
            node[i].id=i;
            scanf("%d%d",&node[i].L,&node[i].R);
        }
        sort(node,node+m,cmp);
        solve();
    }
    return 0;
}

莫队算法完整总结（普通莫队、带修莫队、树上莫队、回滚莫队）
lucius-liu.cn
09-05 3122
普通莫队、带修改莫队、树上带修改莫队、回滚莫队
莫队算法总结&专题训练1
Plozia 的小窝
12-08 610
1.概述 莫队算法，是由莫涛队长提出的一种，能够以玄学的复杂度来处理区间查询类的问题。 甲：区间查询类的问题不是可以用线段树等数据结构解决的吗？ 乙：那如果要求某个区间的区间众数要怎么办呢？ 甲：啊这。。。。。。 所以，莫队算法就是用来解决这种线段树等数据结构不好维护的区间查询问题。 这里先安利几个博客，写的非常好，建议各位读者可以看一看，写的比我好多了： 莫队算法——从入门到黑题（强烈推荐） 洛谷日报 #48 期：莫队算法初探 洛谷日报 #183 期：你以为莫队只能离线？莫队的在线化改造（难度较高，建议
莫队算法详解
热门推荐
hnshhslsh的专栏
01-26 1万+
莫队算法详解 本文翻译自MO’s Algorithm (Query square root decomposition)，作者anudeep2011，发表日期为2014-12-28。由于最近碰到一些莫队算法的题目，找到的相关中文资料都比较简略，而这篇英语文章则讲解的比较详细，故翻译成中文与大家分享。由于本人水平有限，错误在所难免，请谅解。
莫队算法良心讲解
weixin_30483013的博客
09-24 195
问题：有n个数组成一个序列，有m个形如询问L, R的询问，每次询问需要回答区间内至少出现2次的数有哪些。 　　朴素的解法需要读取O(nm)次数。如果数据范围小，可以用数组，时间复杂度为O(nm)。如果使用STL的Map来保存出现的次数，则需要O(nmlogn)的复杂度。有没有更快的方法呢？ 　　注意到询问并没有强制在线，因此我们可以使用离线方法。注意到一点，如果我们有计算完[L, R]时的“中...
莫队算法(Helped With ChatGPT)
xzd20100304的博客
11-26 963
经过前面的逐步讲解，我们已详细解析了莫队算法的基本应用及其各种优化，包括普通莫队、带修改莫队、树上莫队、回滚莫队、二维莫队、二次离线优化以及莫队结合bitset。在本节中，将进一步总结莫队算法的应用场景，分析优缺点，并探讨更多进阶内容，如与其他算法的结合及特殊优化场景。
算法-分治- 莫队算法- 带修莫队（包含源程序）.rar
09-16
总结来说，莫队算法是一种强大的分治策略，通过巧妙地处理区间数据和在线查询，能够在多项式时间内高效解决动态维护区间最值的问题。了解并掌握莫队算法对于提升在算法竞赛和实际编程中的表现具有重要意义。
算法竞赛_数据结构与算法_图论_树算法_基础算法_匹配算法_高精度_动态规划_莫队算法_数学算法_网络流_ACM-ICPC_CCPC_XCPC_金牌选手整理_包含拓扑排序_欧拉回路.zip
最新发布
05-05
本次分享的资料内容广泛，涵盖数据结构与算法的多个关键领域，特别是对图论、树算法、基础算法、匹配算法、高精度计算、动态规划、莫队算法、数学算法以及网络流等核心知识点进行了系统的整理。 图论是计算机科学中...
莫队算法
auiayo82822的博客
03-20 122
留坑 转载于:https://www.cnblogs.com/Superwalker/p/8609096.html
学习笔记：杨辉三角形上莫队（组合数莫队）（LULU胡策）
dingwufu9301的博客
10-23 224
与唐林康的决战在即，面筋哥需要一件压场子的终极武器。 面筋哥手上有 M 个面筋，能量值分别为 1-M 的整数。现在面筋哥想要利用这些面筋制 作他的终极武器：Ex 面筋棒。Ex 面筋棒是一种能够发射强大剑气的能量武器。它由一些面 筋按次序连接而成。Ex 面筋棒可能会发射失败，面筋哥无法承受失败的损失。在 SPW 财团 的资助下，经过上百次的实...
莫队算法学习笔记（一）——普通莫队
CXR的博客
07-28 3072
在学习莫队算法之前，我一直以为这是一个很高深的算法。（实际上，它就是一个很高深的算法） 这个算法玄学地将分块与暴力两大算法实现了二合一，从而打造出了一个时间复杂度为O(nlogn)O(nlogn)O(nlogn)的求解多个区间询问的离线算法。 以下是对这个算法的具体介绍： 首先，我们以询问中lll所在的区间为第一关键字，以rrr的位置为第二关键字进行排序。 然后，我们可以先暴力求解第一个询...
HDU 6333 Problem B. Harvest of Apples（莫队算法+组合数）
baymax520的博客
08-03 185
Problem B. Harvest of Apples Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others) Total Submission(s): 2671    Accepted Submission(s): 1045   Problem D...
hdu5145（莫队算法+组合数逆元）
行云出岫
08-09 404
借鉴了一位大佬的思路：https://www.cnblogs.com/HDUjackyan/p/8996172.html 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5145 题意：一个人有n个女朋友，每个女朋友都有一个班级a[i]，现有m个询问。每个询问有一个区间范围[L,R]，表示这个人想要约[L,R]范围内的女生有几种约法。（第L个女生到...
莫队算法学习笔记
Mys_C_K的博客
03-15 919
莫队算法 有时候我们经常会碰到这样一类问题：给定n和n个数etc，然后给出m组区间询问[L,R],要求对所有询问区间给出答案。 然后发现这类题通常有一个很好的性质就是，如果你知道了[L,R]的答案，就可以O(1)或者O(lgn)（再大就有点玄了）的知道 [L+1,R],[L-1,R],[L,R+1],[L,R-1]的答案，也就是可以很快的拓展左右节点，那么于是发现，与其在线回答每一个问题，不
莫队算法，
敲代码嘞~的博客
04-04 308
莫队算法就是一个离线的，通常针对于区间询问的一种算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值