洛谷4168 [Violet]蒲公英

标签：分块

题目

题目传送门

背景

亲爱的哥哥：

你在那个城市里面过得好吗？

我在家里面最近很开心呢。昨天晚上奶奶给我讲了那个叫「绝望」的大坏蛋的故事的说！它把人们的房子和田地搞坏，还有好多小朋友也被它杀掉了。我觉得把那么可怕的怪物召唤出来的那个坏蛋也很坏呢。不过奶奶说他是很难受的时候才做出这样的事的……

最近村子里长出了一大片一大片的蒲公英。一刮风，这些蒲公英就能飘到好远的地方了呢。我觉得要是它们能飘到那个城市里面，让哥哥看看就好了呢！

哥哥你要快点回来哦！

爱你的妹妹 Violet

Azure 读完这封信之后微笑了一下。

“蒲公英吗……”

题目描述

在乡下的小路旁种着许多蒲公英，而我们的问题正是与这些蒲公英有关。

为了简化起见，我们把所有的蒲公英看成一个长度为n的序列 $(a_1,a_2..a_n)$，其中 $a_i$ 为一个正整数，表示第i棵蒲公英的种类编号。

而每次询问一个区间 [l,r]，你需要回答区间里出现次数最多的是哪种蒲公英，如果有若干种蒲公英出现次数相同，则输出种类编号最小的那个。

注意，你的算法必须是在线的

输入输出

第一行两个整数 m,n ，表示有n株蒲公英，m 次询问。

$$接下来一行n个空格分隔的整数 a_i ，表示蒲公英的种类$$

$$再接下来m 行每行两个整数 l_0,r_0，我们令上次询问的结果为 x（如果这是第一次询问， 则 x=0）。$$

$$令 l=(l_0+x-1)\bmod n + 1,r=(r_0+x-1) \bmod n + 1，如果 l>r，则交换 l,r 。$$

最终的询问区间为[l,r]。

输出m 行。每行一个整数，表示每次询问的结果。

样例

输入
6 3
1 2 3 2 1 2
1 5
3 6
1 5
输出
1
2
1

$$对于 20\% 的数据，保证 1\le n,m \le 3000。$$

$$对于 100\% 的数据，保证 1\le n \le 40000,1\le m \le 50000,1\le a_i \le 10^9。$$

分析

题意就是强制在线求区间众数

首先你要知道一个性质：维护一个集合的众数，这个众数要么是当前集合内出现次数最多的那个数，要么存在于新加入的那些数中

先离散化，然后分块

预处理f[i][j]表示从第i块到第j块的众数

之后对于每个离散化后的数开vector，记录下出现的位置

查询的时候，对于整块，直接可以二分查找

两侧的零散块，对于出现的每一个数字，都需要二分判断是不是更新的众数

code

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define ll long long
#define mem(x,num) memset(x,num,sizeof x)
#define reg(x) for(int i=last[x];i;i=e[i].next)
using namespace std;
inline ll read()
{
    ll f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int maxn=5e4+6;
int ans=0,n,m,tnum,id,a[maxn],b[maxn],f[1006][1006],val[maxn],cnt[maxn];
vector<int>v[maxn];
map<int,int>Map;
void pre(int x){
    mem(cnt,0);int mx=0,ret=0;
    rep(i,(x-1)*tnum+1,n){
        cnt[a[i]]++;
        if(cnt[a[i]]>mx||(cnt[a[i]]==mx&&val[a[i]]<val[ret]))ret=a[i],mx=cnt[a[i]];
        f[x][b[i]]=ret;
    }
}
inline int query(int l,int r,int x){
    int tmp=upper_bound(v[x].begin(),v[x].end(),r)-lower_bound(v[x].begin(),v[x].end(),l);
    return tmp;
}
inline int query(int x,int y){
    int re=f[b[x]+1][b[y]-1],mx=query(x,y,re); //二分查询整块 
    rep(i,x,min(b[x]*tnum,y)){
        int t=query(x,y,a[i]);
        if(t>mx||(t==mx&&val[a[i]]<val[re]))re=a[i],mx=t;
    }
    if(b[x]!=b[y])
        rep(i,(b[y]-1)*tnum+1,y){
            int t=query(x,y,a[i]);
            if(t>mx||(t==mx&&val[a[i]]<val[re]))re=a[i],mx=t;
        }//两个零散块暴力查询 
    return re;
}   
int main(){
    n=read(),m=read();tnum=100;
    rep(i,1,n){
        a[i]=read();
        if(!Map[a[i]])Map[a[i]]=++id,val[id]=a[i];
        a[i]=Map[a[i]];
        v[a[i]].push_back(i);
    }//离散化部分 
    rep(i,1,n)b[i]=(i-1)/tnum+1;
    rep(i,1,b[n])pre(i);//预处理出f[x][y] 
    rep(i,1,m){
        int x=read(),y=read();
        x=(x+ans-1)%n+1,y=(y+ans-1)%n+1;if(x>y)swap(x,y);
        ans=val[query(x,y)];
        printf("%d\n",ans);
    }
    return 0;
}