莫队算法小总结 x

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了莫队算法小总结 x相关的知识,希望对你有一定的参考价值。

莫队这东西...orz

  • 可用于解决一类可离线且在得到区间[l,r]的答案后,能在O(1)O(log2n)得到区间[l,r+1]或[l−1,r]的答案的问题

    我们先来看这样一个问题:

给出n个数字,m次询问,每次询问在区间[li,ri]之间任选两个数字相等的概率是多少。(n,q<=50000)(小z的袜子)

  在区间[l,r]中,这个概率是:

        ∑vi=1C(2,f(i))
        -----------------
        C(2,rl+1)

    (v表示数字值,f(i)表示数字i在区间内出现的次数)

由于没有加和性质,传统的线段树什么的完全派不上用场了呢!

考虑分子,因为    x2x

       C(2,x--------

            2

 

        ∑vi=1f(i)2vi=f(i)

  所以分子=-----------------------------

             2
显然 vi=f(i)=rl+1

若得知区间[l,r]的答案怎么求区间[l,r+1]的答案呢?仔细想想。恩,有了。区间[l,r+1]与区间[l,r]相比只多了一个元素Z,这种改动是很小的,

那么前式中分子的值S=S0f(Z)2+(f(Z)+1)21=S0+2f(Z),同时++f(z)。

恩,O(1)的。

这样的话,在处理下一个询问[li,ri]时,复杂度就是O(|rri|+|lli|)的。

同样的方法,也可以在O(1)内求出[l1,r],[l+1,r],[l,r1].这样的方法对于随机数据表现是很好的,但也不难给出故意卡你的数据。

这时,就需要莫队算法来撑腰了,这也是莫队算法优化的精髓。

注意到,每个区间可以抽象成平面中的点,每次转移的花费都相当与从某点到另一点的曼哈顿距离的长度。恩,所以呢?

所以我们花费的便是这些平面中的点联通的曼哈顿距离。平面点的曼哈顿最小生成树

对!但平面点的曼哈顿最小生成树怎么求呢?枚举两两点连接O(n2),毫无意义。

其实平面点的曼哈顿最小生成树有基于平面区域划分的O(nlog2n)的求法,但我们有更简洁的方法。

对,就是分块!

  • 神犇曰:分块是个好东西!

确实,利用分块,我们可以实现O(n√n)的时间复杂度。

虽然求解平面点的曼哈顿最小生成树是O(nlog2n)的,但根据莫队论文中的证明,用到这里时,仍然是O(n√n)),只不过常数小一些罢了。

  • 分块的做法:

x=(√n),以[1,x],[x+1,2x],[2x+1,3x]..分块
用pos数组维护端点i在第pos[i]块中,然后就搞呗。

这样搞:

  1):排序,以左端点所在的块为第一关键字,以右端点为第二关键字

  2):从左往右处理询问(离线)

  3):不断调整l,r的位置并同时修改

  • 时间复杂度证明:
      右端点移动:
首先我们考虑一个块里面的转移情况
由于一个块里面的询问都按右端点排序
所以我们右端点在一个块里面最多移动n次
有 O(√n)个块,那么同一个块内的右端点移动最多就是O(n√n)
然后考虑从一个块到另一个块导致的右端点变化
最坏情况,右端点由n到1,那么移动n次
有 O(√n)个块
那么从一个块到另一个块的事件只会发生O(√n)次……
所以这种右端点移动的次数也是O(n√n)次
没有别的事件导致右端点移动了
      左端点移动:
同一个块里面,由于左端点都在一个长度为O(√n)的区间里面
所以在同一块里面移动一次,左端点最多变化O(√n)
总共有n个询问……
所以同一块里面的移动最多n次
那么同一个块里面的左端点变化最多是O(n√n)的
考虑跨越块
每由第i个块到第i+1个块,左端点最坏加上O(√n)
总共能加上O(√n)次
所以跨越块导致的左端点移动是O(n)的
综上,分块做法是O(n∗√n)。

总结

莫队算法在解决离线区间询问几乎是无敌的。
恩,几乎只要能离线,用分块的莫队算法都能取得一个令人满意的的解法。
所以就有很多扩展(解决线段树等数据结构由于需要区间加和性而不能解决的问题),如区间众数,平均数什么的。
恩。真棒!

给出几道练手题 ̄へ ̄:

例1.bzoj2038: [2009国家集训队]小Z的袜子(hose)

Time Limit: 20 Sec  Memory Limit: 259 MB
Submit: 10401  Solved: 4713
[Submit][Status][Discuss]

Description

作为一个生活散漫的人,小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。

HINT

 

Source

思路_(:з」∠)_:
  这个好像是最简单的莫队模板啦~
上代码(≧▽≦)/:
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cmath>
#define LL long long
using namespace std;

const int N = 50010; 
int n,m,curL,curR;
LL answer;
int a[N],block[N];
LL cnt[N];

struct G {
    int l,r,id;
    LL x,y;
}t[N];

bool cmp(G a,G b)
{
    if(block[a.l]==block[b.l]) 
        return a.r < b.r;
    return a.l < b.l;
}

bool idcmp(G a,G b)
{ return a.id < b.id; }

LL gcd(LL a,LL b){ return b == 0 ? a : gcd(b,a%b); }

LL squ(LL x){ return x*x; }

void change(int pre,int flag)
{
    answer-=squ(cnt[a[pre]]);
    cnt[a[pre]]+=flag;
    answer+=squ(cnt[a[pre]]);
}

void solve()
{
    sort(t+1,t+m+1,cmp);
    /*
    for(int i=1;i<=m;i++)
        printf("%d %d\\n",t[i].l,t[i].r);
    */
    curL=1,curR=0;
    for(int i=1;i<=m;i++)
    {
        int L=t[i].l,R=t[i].r;
        while(curL<L)
            change(curL++,-1);
        while(curL>L)
            change(--curL,1);
        while(curR<R)
            change(++curR,1);
        while(curR>R)
            change(curR--,-1);
        if(L==R)
        {
            t[i].x=0,t[i].y=1;
            continue;
        }
        t[i].x=answer-(t[i].r-t[i].l+1);
        t[i].y=(LL)(t[i].r-t[i].l+1)*(t[i].r-t[i].l);
//      printf("%d %d\\n",t[i].x,t[i].y);
        LL k=gcd(t[i].x,t[i].y);
//      printf("%d\\n",k);
        t[i].x/=k,t[i].y/=k;
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    int size=(int)(sqrt(n));
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        block[i]=(i-1)/size+1;
    }
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&t[i].l,&t[i].r);
        t[i].id=i;
    }
    solve();
    sort(t+1,t+m+1,idcmp);
    for(int i=1;i<=m;i++)
        printf("%lld/%lld\\n",t[i].x,t[i].y);
    return 0;
}

例2.luoguP1972 [SDOI2009]HH的项链

    • 693通过
    • 1.5K提交
  • 题目提供者 lych
  • 标签 各省省选 2009山东 云端
  • 难度 提高+/省选-
  • 时空限制 1s / 128MB

题目背景

题目描述

HH 有一串由各种漂亮的贝壳组成的项链。HH 相信不同的贝壳会带来好运,所以每次散步完后,他都会随意取出一段贝壳,思考它们所表达的含义。

HH 不断地收集新的贝壳,因此,他的项链变得越来越长。

有一天,他突然提出了一个问题:某一段贝壳中,包含了多少种不同的贝壳?这个问题很难回答……因为项链实在是太长了。

于是,他只好求助睿智的你,来解决这个问题。

输入输出格式

输入格式:

第一行:一个整数N,表示项链的长度。

第二行:N 个整数,表示依次表示项链中贝壳的编号(编号为0 到1000000 之间的整数)。

第三行:一个整数M,表示HH 询问的个数。

接下来M 行:每行两个整数,L 和R(1 ≤ L ≤ R ≤ N),表示询问的区间。

输出格式:

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

输入输出样例

输入样例#1:
6
1 2 3 4 3 5
3
1 2
3 5
2 6
输出样例#1:
2
2
4

说明

数据范围:

对于100%的数据,N <= 50000,M <= 200000。

 思路o_O:

  1)莫队

  2)离线+树状数组(然而我并不会(?¯∀¯?))

上代码╰( ̄▽ ̄)╮:

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#define LL long long
using namespace std;

const int N = 50010; 
const int M = 200010;
int n,m,k,curL,curR;
int answer;
int a[N];
LL cnt[M],ans[M];

struct G {
    int l,r,id,block;
    bool operator < (const G &qwq)const
    {
        if(block==qwq.block) 
            return r < qwq.r;
        else 
            return block < qwq.block;
    }
}t[M];

void add(int pre)
{
    if(++cnt[a[pre]] == 1)
        answer++;
}

void change(int pre)
{
    if(--cnt[a[pre]] == 0)
        answer--;
}

void modui()
{
    sort(t+1,t+m+1);
    curL=1,curR=0;
    for(int i=1;i<=m;i++)
    {
        int L=t[i].l,R=t[i].r;
        while(curL<L)
            change(curL++);
        while(curL>L)
            add(--curL);
        while(curR<R)
            add(++curR);
        while(curR>R)
            change(curR--);
        ans[t[i].id]=answer;
    }
}

int main()
{
    scanf("%d",&n);
    int size=sqrt(n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    scanf("%d",&m);
    for(int i=1,l,r;i<=m;i++)
    {
        scanf("%d%d",&t[i].l,&t[i].r);
        t[i].id=i;
        t[i].block=(t[i].l-1)/size+1;
    }
    modui();
    for(int i=1;i<=m;i++)
        printf("%d\\n",ans[i]);
    return 0;
}

例3.luoguP2709 小B的询问

    • 157通过
    • 244提交
  • 题目提供者 BDF1
  • 标签 云端↑
  • 难度 提高+/省选-
  • 时空限制 1s / 128MB

题目描述

小B有一个序列,包含N个1~K之间的整数。他一共有M个询问,每个询问给定一个区间[L..R],求(Sigma)∑(c(i)^2)的值,其中i的值从1到K,其中c(i)表示数字i在[L..R]中的重复次数。

小B请你帮助他回答询问。

输入输出格式

输入格式:

第一行,三个整数N、M、K。

第二行,N个整数,表示小B的序列。

接下来的M行,每行两个整数L、R。

输出格式:

M行,每行一个整数,其中第i行的整数表示第i个询问的答案。

输入输出样例

输入样例#1:
6 4 3
1 3 2 1 1 3
1 4
2 6
3 5
5 6
输出样例#1:
6
9
5
2

说明

对于全部的数据,1<=N、M、K<=50000

思路O(∩_∩)O~~:

  裸的莫队题...只是可惜我是真的没搞明白为什么可以这样做...然后胡乱敲了一个模板,啪的一下就AC了....

坑点╭(╯^╰)╮:

  看样子好像并没有使用到k...

上代码{>~<}:

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#define LL long long
using namespace std;

const int N = 50010; 
int n,m,k,curL,curR;
int answer;
int a[N];
LL cnt[N],ans[N];

struct G {
    int l,r,num,block;
    bool operator < (const G &qwq)const
    {
        if(block==qwq.block) 
            return r < qwq.r;
        else 
            return block < qwq.block;
    }
}t[N];

void change(int pre,bool flag)
{
    if(flag)
        answer-=(--cnt[a[pre]])<<1|1;
    else
        answer+=(cnt[a[pre]]++)<<1|1;
}

void modui()
{
    sort(t+1,t+m+1);
    curL=1,curR=0;
    for(int i=1;i<=m;i++)
    {
        int L=t[i].l,R=t[i].r;
        while(curL<L)
            change(curL++,1);
        while(curL>L)
            change(--curL,0);
        while(curR<R)
            change(++curR,0);
        while(curR>R)
            change(curR--,1);
        ans[t[i].num]=answer;
    }
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    int size=sqrt(n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    for(int i=1,l,r;i<=m;i++)
    {
        scanf("%d%d",&t[i].l,&t[i].r);
        t[i].num=i;
        t[i].block=(t[i].l-1)/size+1;
    }
    modui();
    for(int i=1;i<=m;i++)
        printf("%lld\\n",ans[i]);
    return 0;
}

(___r___)

参考博客:

1.http://foreseeable97.logdown.com/posts/158522-233333

2.http://www.cnblogs.com/hzf-sbit/p/4056874.html

3.http://ydcydcy1.blog.163.com/blog/static/21608904020134411543898/

4.http://vawait.com/manhattanmst/

5.http://blog.csdn.net/huzecong/article/details/8576908

6.http://hzwer.com/2782.html

 

以上是关于莫队算法小总结 x的主要内容,如果未能解决你的问题,请参考以下文章

莫队算法(离线区间查询问题)(莫队,分块)

算法总结根号算法相关

CodeForces - 220B 离散化+莫队算法

P1494 [国家集训队]小Z的袜子(莫队算法)

莫队算法小介绍——看似暴力的莫队算法

莫队算法&#183;初探总结