算法 {莫队}

已于 2024-03-05 19:52:44 修改
阅读量378 收藏 8
点赞数 10
分类专栏： 算法 文章标签： 算法
于 2024-01-13 17:24:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66485519/article/details/135573024
版权

算法 {莫队}

莫隊算法

性質

#排序比較函數, 必須是全序的#
比如你單個查詢的參數有X個, 那麽做法是把前X-1個參數 進行分塊, 然後對最後一個參數 直接排序 不要進行分塊;

@DELI;

錯誤

#其實是正確的#: 右端點(即第二排序關鍵字) 不用分塊 直接排序即可;
也就是if( 左端點是同一個塊内){ return 右端點} 而不是return 右端點分塊后的塊號;, 否則會產生以下錯誤:
0: 你的比較函數 不是全序的 而是偏序的, 這不符合莫隊算法的規定;
1: 時間會大大降低; 對於l在同一個塊裏的查詢們(假設有C個) 他們的r端點 會一直在震蕩(震蕩長度是塊長) 此時r端點的移動次數是C*塊長; 而如果直接對r端點排序(不分塊) 那麽時間是N(數組長度);

@DELI;

莫队算法时间本身就比较极限, 请确保Add,Delete函数的效率是O(1)的, 否则的话 即使是O(logN) 也是会超时的 参见@LINK: 题解;

數組區間查詢

定義

#問題#: 參見例題@LINK: https://www.acwing.com/problem/content/description/2494/; 對於長度為N的數組A, 共有M個查詢 每次查詢A[l...r]這個區間的信息;

#算法#: 將所有查詢做離散化處理 即進行排序, 排序規則為: 對於[l,r], 第一權重:[左端點進行分塊 按照塊號b_l遞增], 第二權重:[如果b_l是偶數 則按照r遞增, 否則遞減];

性質

#右端點 為什麼要奇偶相間#
比如數組長度N, 分塊長度為x, 即一共分為[0,1,...N/x)個塊;
第0塊 是按照r遞增的, 即你遍歷完所有左端點在0塊的區間查詢後, 此時r端點會非常的大;
到第1塊時 此時讓r遞減, 這樣就和上一次的r就拼接對應了, 就會讓r的移動 變小;

時間為: 右端點移動次數 + 左端點移動次數 = N/x(塊個數,表示左端點在同一個塊内的查詢) * N(左端點在同一塊內的右端點的移動次數) + M(查詢次數) * x(每次查詢 左端點都是移動x);
解這個方程 N*N/x + M*x, 他倆的乘積是個定值 而且N*N/x, M*x > 0, 所以根據算術-幾何不等式 (N*N/x + M*x)/2 >= sqrt(N*N/x * M*x), 當N*N/x == M*x時 此時會讓他倆的和 最小, 因此我們讓x = sqrt(N*N/M), 此時時間複雜度是N * sqrt(M);

@DELI;

錯誤

#Delete元素時 此時該元素 不一定存在於所維護的集合裡, 即此時她的Cont 不一定是>0的;#
舉個例子, [3,4] -> [6,7] 他倆在同一塊 且這個塊是r遞增, 先移動l端點 即把[3,4,5]給刪除掉 但5是不存在的 因此會導致Cont[5] = -1, 等到移動r時 會把5再給補回來;
. 你可能認為 那我先移動r端點? 也不行, 比如[6,7] -> [3,4] 這個塊是r遞減的, 那麼你會把[7,6,5]給刪除 同樣會導致Cont[5] = -1;

代碼模板

namespace ___MoTao_Queue{

vector<int> __Array; // 原數組;
vector< pair<int,int> > __Querys; // 她的次序不會變 (即與題目查詢的次序保持一致);
vector<int> __Order;
vector<int> ANS; // `ANS[i]`表示第`i`查詢對應的答案;

namespace __CurrentInfo{
    int ANS;
    int Cont[ ?]; // 所有`Array`的元素 必須是可以放到下標裏面;
    void Add( int _ind){
        ++ Cont[ __Array[_ind]];  if( Cont[ __Array[_ind]] == 1){; ++ ANS;}
    }
    void Delete( int _ind){
        -- Cont[ __Array[_ind]];  if( Cont[ __Array[_ind]] == 0){ -- ANS;}
    }
} // namespace __CurrentInfo

void Initialize(){
    @TODO( 檢查錄入格式是否合法);
    int N;  cin>> N;
    __Array.resize( N);  for( auto & i : __Array){ cin>> i;}
    int M;  cin>> M;
    __Querys.resize( M);  for( auto & i : __Querys){ cin>> i.first>> i.second;  --i.first, --i.second;}
}
void Work(){
    int __blockLength = std::sqrt( ((Double)__Array.size() * __Array.size() / __Querys.size()).v);  __blockLength = max( __blockLength, 1);
    __Order.resize( __Querys.size());  std::iota( __Order.begin(), __Order.end(), 0);
    std::sort( __Order.begin(), __Order.end(), [&]( int _a, int _b)->bool{
        auto block0 = __Querys[_a].first / __blockLength;
        auto block1 = __Querys[_b].first / __blockLength;
        if( block0 != block1){ return block0 < block1;}
        if( block0 & 1){ return __Querys[_a].second > __Querys[_b].second;}
        return __Querys[_a].second < __Querys[_b].second;
    });
    //{ __CurrentInfo
    __CurrentInfo::ANS = 0;
    memset( __CurrentInfo::Cont, 0, sizeof( __CurrentInfo::Cont));
    //} __CurrentInfo
    ANS.resize( __Querys.size());
    int cl = __Querys[ __Order.front()].first, cr = cl-1;
    for( auto ord : __Order){
        int tl = __Querys[ ord].first, tr = __Querys[ ord].second;
        while( cl < tl){ __CurrentInfo::Delete( cl ++);}
        while( cl > tl){ __CurrentInfo::Add( -- cl);}
        while( cr < tr){ __CurrentInfo::Add( ++ cr);}
        while( cr > tr){ __CurrentInfo::Delete( cr --);}
        ANS[ ord] = __CurrentInfo::ANS;
    }
}
} // namespace ___MoTao_Queue

例題

@LINK: https://editor.csdn.net/md/?not_checkout=1&articleId=135573017;
查詢子區間的不同元素個數

@DELI;

@LINK: https://editor.csdn.net/md/?not_checkout=1&articleId=136464598;
這個題 如果用莫隊 是會超時的…

數組區間查詢+單點修改

定義

@LINK: https://www.acwing.com/problem/content/description/2523/;

代碼

namespace ___MoTao_Queue{

vector<int> __Array; // 原數組;
vector< tuple<int,int,int> > __Modifys; // {下標,修改前的值,修改后的值}
vector< tuple<int,int,int> > __Querys; // {左端點,右端點,修改時間} (比如令`t:修改時間` 他表示執行`Modifys[0...t]`這些修改后的數組,因此`-1<=t<Modifys.size()`); 她的次序不會變 (即與題目查詢的次序保持一致);
vector<int> __Order;
vector<int> ANS; // `ANS[i]`表示第`i`查詢對應的答案;

namespace __CurrentInfo{
    int ANS;
    int Cont[ 1000006]; // 所有`Array`的元素 必須是可以放到下標裏面;
    void Add( int _v){ ++ Cont[_v];  if( Cont[_v] == 1){; ++ ANS;}}
    void Delete( int _v){ -- Cont[_v];  if( Cont[_v] == 0){ -- ANS;}}
} // namespace __CurrentInfo

void Initialize(){
    int N;  cin>> N;
    int M;  cin>> M; // 操作個數(查詢加上修改的總和 即`__Modifys.size() + __Querys.size() == M`);
    __Array.resize( N);  for( auto & i : __Array){ cin>> i;}
    __Querys.clear();  __Modifys.clear();
    string op; int d0, d1;
    for( int m = 0; m < M; ++m){
        cin>> op>> d0>> d1;
        if( op == "Q"){
            -- d0, -- d1;
            __Querys.emplace_back( d0, d1, int(__Modifys.size()) - 1);
        }
        else{
            -- d0;
            __Modifys.emplace_back( d0, __Array[d0], d1);
            __Array[d0] = d1;
        }
    }
}
void Work(){
    int __blockLength = std::sqrt( __Array.size());  __blockLength = max( __blockLength, 1);
    __Order.resize( __Querys.size());  std::iota( __Order.begin(), __Order.end(), 0);
    std::sort( __Order.begin(), __Order.end(), [&]( int _a, int _b)->bool{
        int la = std::get<0>(__Querys[_a])/ __blockLength;
        int lb = std::get<0>(__Querys[_b])/ __blockLength;
        if( la != lb){ return la < lb;}
        int ra = std::get<1>(__Querys[_a])/ __blockLength;
        int rb = std::get<1>(__Querys[_b])/ __blockLength;
        if( ra != rb){ return ra < rb;}
        return std::get<2>(__Querys[_a]) < std::get<2>(__Querys[_b]);
    });
    //{ __CurrentInfo
    __CurrentInfo::ANS = 0;
    memset( __CurrentInfo::Cont, 0, sizeof( __CurrentInfo::Cont));
    //} __CurrentInfo
    ANS.resize( __Querys.size());
    int cl = std::get<0>(__Querys[ __Order.front()]), cr = cl-1, ct = int(__Modifys.size())-1;
    for( auto ord : __Order){
        int tl = std::get<0>(__Querys[ ord]), tr = std::get<1>(__Querys[ ord]), tt = std::get<2>(__Querys[ord]);
        while( ct < tt){
            int ind = std::get<0>(__Modifys[ct+1]), oldV = std::get<1>(__Modifys[ct+1]), newV = std::get<2>(__Modifys[ct+1]);
            ++ ct;  __Array[ ind] = newV;
            if( ind>=cl && ind<=cr){ __CurrentInfo::Delete( oldV);  __CurrentInfo::Add( newV);}
        }
        while( ct > tt){
            int ind = std::get<0>(__Modifys[ct]), oldV = std::get<1>(__Modifys[ct]), newV = std::get<2>(__Modifys[ct]);
            -- ct;  __Array[ ind] = oldV;
            if( ind>=cl && ind<=cr){ __CurrentInfo::Delete( newV);  __CurrentInfo::Add( oldV);}
        }
        while( cl < tl){ __CurrentInfo::Delete( __Array[cl]);  ++cl;}
        while( cl > tl){ __CurrentInfo::Add( __Array[cl-1]);  --cl;}
        while( cr < tr){ __CurrentInfo::Add( __Array[cr+1]);  ++cr;}
        while( cr > tr){ __CurrentInfo::Delete( __Array[cr]);  --cr;}

        ANS[ ord] = __CurrentInfo::ANS;
    }
}
} // namespace ___MoTao_Queue

錯誤

@LINK: https://editor.csdn.net/md/?articleId=136464598;
這個題 不能用莫隊, 因爲你會導致Add/Delete函數 不是O(1);

筆記

中國算法選手莫涛所發明的;

排序時:
@IF( 奇數則右端點遞減): 效率會高 (因為右端點會相近 左端點不用管), 但會導致一個問題: Delete時 她可能不存在, 比如同一個塊內[4,6] -> [2,3];

omipus
关注
专栏目录
秒懂算法 | 莫队算法
不断学习，不断进步，提高自己
02-20 3219
本篇介绍了莫队算法的几何意义、基本莫队、带修改莫队以及树上莫队的相关内容。
莫队算法完整总结（普通莫队、带修莫队、树上莫队、回滚莫队）
Gene_I must wait for the sunrise
09-05 2708
普通莫队 带修改莫队 树上带修改莫队 回滚莫队
莫队算法
christ_lrs的博客
03-31 1947
莫队算法，是由莫涛队长提出的，能够以玄学的复杂度处理区间查询类的问题。也可以说，他使用来解决线段树等数据结构不好维护的区间查询问题。
【算法】莫队算法
Just__Do__IT__的博客
07-22 8918
文章目录莫队算法概述：算法过程：时间复杂度：例题：1.洛谷P2709 小B的询问代码思路：完整代码：2.HDU - 6959 zoto题目大意：代码思路：完整代码： 莫队算法概述： 莫队算法是由莫涛发明的算法，所以称为莫队算法。 莫队算法是一个对于区间、树或其他结构离线（在线）维护的算法，此算法基于一些基本算法，例如暴力维护，树状数组，分块，最小曼哈顿距离生成树，对其进行糅合从而产生的算法 其主要用来处理离线的区间问题，如区间和。看到这你会想到线段树，但是他与线段树相比，优点就是可以处理离散的信息，而且代码
详谈莫队算法
Tudou_Pika的博客
02-26 1135
本文分别在1、2、3章介绍了普通莫队、带修莫队和回滚莫队算法并详细地分析了最优块长和相对应的时间复杂度。 同时各给出了一道例题的实现。 本文参考了诸多资料，统一置于文末，读者可自行查阅。
【算法学习】分块算法 莫队
memcpy0的博客
08-24 350
文章目录1. 莫队概述2. 挪动区间3. 某种顺序和离线处理4. 莫队算法框架5. 应用题 今天要学习的算法是莫队算法基础版本。 1. 莫队概述 莫队是一种解决区间问题的离线算法。它的思想很简单，本质上就是通过挪动区间的方式按照某种顺序，离线处理区间查询操作。 它的时间复杂度是 O(nn)\text{O(n}\sqrt{n})O(nn​) ，是一种效率不错的算法，可以解决几乎所有的区间查询问题（需要离线），只要对时间复杂度的要求不是那么苛刻。 2. 挪动区间 假设有这样的一道题：对于一个数列，每次给出一个
莫队算法详解
riba2534的博客
08-04 508
莫队算法详解 转载自：莫队算法详解 本文在本人新博客的链接：http://www.myblog.link/2016/01/26/MO-s-Algorithm/ 本文翻译自MO’s Algorithm (Query square root decomposition)，作者anudeep2011，发表日期为2014-12-28。由于最近碰到一些莫队算法的题目，找到的相关中文资料都比较简略，...
算法基础——莫队基础
m0_52766855的博客
04-11 752
知识点1: (普通)莫队的概念 (普通)莫队算法是一种优化的暴力算法，用于解决区间查询的离线算法，基于分块的思想，时间复杂度 O(mn+nn)O(m\sqrt n+n\sqrt n)O(mn​+nn​) 什么时候使用莫队？ 当对于一个查询 [l,r][l,r][l,r]，能够在 O(1)O(1)O(1) 的时间内把 [l,r][l,r][l,r] 的答案转移到相邻的区间 [l,r−1][l,r-1][l,r−1]，[l,r+1][l,r+1][l,r+1] …此时可以考虑使用(普通)莫队算法 莫队的算法核心
莫队算法思想
Psychosocial的博客
04-13 733
莫队算法是由前国家队莫涛提出的一种算法，主要应用在一类离线区间查询的问题中，同时具有多种扩展的应用，其主要思想是分块。
莫队算法 --算法竞赛专题解析（26）
罗勇军的博客
09-09 7236
莫队算法的几何意义、基本莫队、带修改莫队、树上莫队
莫队算法详解 - anudeep20111
08-03
莫队算法，又称莫队查询平方根分解，是一种在处理在线区间查询问题时，通过预处理和优化查询处理过程来降低时间复杂度的算法。它主要用于处理一系列区间查询，其中每个查询要求对某个区间内的数据进行操作或统计。在...
md_莫队_visitorkir_algorithm_
09-28
莫队算法，全称为“Visitor Kir Algorithm”，是由中国著名算法竞赛选手莫队提出的一种高效解决在线询问问题的算法。在编程竞赛和算法设计领域，它以其独特的思想和优秀的性能受到广泛关注。莫队算法主要适用于处理...
算法-分治- 莫队算法- 普通莫队（包含源程序）.rar
09-16
莫队算法，又称“Moreau's Algorithm”，是计算机科学领域中一种高效的算法设计思想，尤其在处理线性规划问题和动态规划问题时表现突出。它属于分治策略的一种，主要应用于解决在线查询优化问题，例如二维最短路径、...
算法-分治- 莫队算法- 带修莫队（包含源程序）.rar
09-16
**莫队算法（Mo's Algorithm）**是一种高效解决在线询问问题的分治策略，尤其在处理动态维护区间最值的问题时表现出色。该算法由莫军（也译为莫队，Mo De）提出，常用于解决如“区间最值查询”、“区间加权更新”等...
算法复习1
08-08
算法是计算机科学的基础，它是解决问题的精确步骤集合。在复习算法时，我们首先需要理解算法的基本概念和特性。算法必须具备五个关键特征：输入、输出、确定性、有限性和可行性。输入可以是零个或多个有效值，输出是...
【18】输出字符菱形
2301_78786609的博客
07-19 365
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
2024.7.19 刷题总结
最新发布
TheJustice_的博客
07-19 221
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
(算法)区间调度问题
2202_75519246的博客
07-17 238
此外,参与工作的时间段不能重复(即使是开始的瞬间和结束的瞬间的重叠也是不允许的). 你的目标是参与尽王多的工作,那么最多能参与多少项工作呢?有n项工作,每项工作分别在s时间开始,在t时间结束. 对于每项工作,你都可以选择参与与否,如果选择了参与,那么自始至终都必须全程参与.
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 170
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
莫队算法 python
03-29
莫队算法是一种基于分块的算法，用于解决一些静态区间查询问题，时间复杂度为 $O(n\sqrt{n})$。以下是一个基于Python的莫队算法的示例代码： ```python import math # 定义块的大小 BLOCK_SIZE = 0 # 初始化块的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值