区间众数问题
区间众数问题一般是指给定一个序列，每次询问 ([l,r]) 区间的众数是几的问题。
当然了，带修改的区间众数问题比较难搞，这里不展开讨论，只研究静态的区间众数问题。
众数并不满足区间“可加性”，这导致它让全部基于二分的数据结构直接 gg （比如线段树、树状数组等），所以大部分研究区间众数的算法都是基于分块。
目前我知道的最优秀的求解区间众数的算法是数据结构带师 lxl 在 Ynoi 毒瘤模拟赛给出的 (O(n^{1.485})) 的在线算法。不过我是不会，今天只介绍一个 (O(n^{1.5})) 的离线做法和以及一个 (O(n^{frac 5 3})) 的在线做法。
直接结合例题分析吧。
T1 faebdc 的烦恼
题目链接：Link
题目描述：
给定一个长度为 (N) 的序列，有 (q) 次询问，每次询问一个区间 ([l,r]) 的众数出现的次数。
Solution：
这题比区间众数问题简化了一点，我们只需要求出众数出现的次数就行了，减少了一些麻烦。
看到“众数”直接考虑分块就行了。这题不强制在线，我选择了离线的莫队算法。发现向答案区间添加一个数实现比较简单，可以顺便更新众数出现次数。而删除操作比较操蛋，如果我们正好删除了区间的众数之一，可能导致众数改变，而我们在不扫描值域的情况下，不能得知新的众数出现次数是多少。
emmmm... 这不就是裸的回滚莫队吗？
回滚莫队我之前讲过，这是模板题所以不再详细注释代码了，想看详细注释的朋友移步这里。
Code：
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<iostream>
//using namespace std;
//Rool Back CaptianMo's Algorithm
#define int long long
const int maxn=200005;
template <typename _T>
inline _T const& read(_T &x){
x=0;int f=1;
char ch=getchar();
while(!isdigit(ch)){
if(ch=='-')
f=-1;
ch=getchar();
}
while(isdigit(ch)){
x=(x<<3)+(x<<1)+ch-'0';
ch=getchar();
}
return x*=f;
}
int n,q,len,tot;
int A[maxn],B[maxn];
int bel[maxn],L[maxn],R[maxn];
struct Node{
int l,r,org;
};
struct Node query[maxn];
inline bool operator < (const Node a,const Node b){
return bel[a.l]!=bel[b.l]?bel[a.l]<bel[b.l]:a.r<b.r;
}
void Init(){
read(n),read(q);
len=(int)std::sqrt(n);
tot=n/len;
for(int i=1;i<=tot;++i){
if(i*len>n) break;
L[i]=(i-1)*len+1;
R[i]=i*len;
}
if(R[tot]<n)
tot++,L[tot]=R[tot-1]+1,R[tot]=n;
for(int i=1;i<=n;++i){
bel[i]=(i-1)/len+1;
B[i]=read(A[i]);
}
std::sort(B+1,B+1+n);
int m=std::unique(B+1,B+1+n)-B-1;
for(int i=1;i<=n;++i)
A[i]=std::lower_bound(B+1,B+m+1,A[i])-B;
for(int i=1;i<=q;++i)
read(query[i].l),read(query[i].r),query[i].org=i;
}
int cnt[maxn],cnt1[maxn];
int ans;
inline void add(const int i){
cnt[A[i]]++;
ans=ans>cnt[A[i]]?ans:cnt[A[i]];
}//核心，添加的同时更新众数出现次数
inline void del(const int i){
cnt[A[i]]--;//直接删除，不考虑影响
}
int ans1[maxn];
signed main(){
Init();
std::sort(query+1,query+q+1);
int l=R[bel[query[1].l]]+1,r=R[bel[query[1].l]],last=bel[query[1].l];
for(int i=1;i<=q;++i){
if(bel[query[i].l]==bel[query[i].r]){
int tmp=0;
for(int j=query[i].l;j<=query[i].r;++j)
cnt1[A[j]]++;
for(int j=query[i].l;j<=query[i].r;++j)
tmp=tmp>cnt1[A[j]]?tmp:cnt1[A[j]];
for(int j=query[i].l;j<=query[i].r;++j)
cnt1[A[j]]--;
ans1[query[i].org]=tmp;
continue;
}
if(bel[query[i].l]!=last){
while(r>R[bel[query[i].l]])
del(r--);
while(l<R[bel[query[i].l]]+1)
del(l++);
ans=0,last=bel[query[i].l];
}
while(r<query[i].r)
add(++r);
int tmp=ans,l1=l;
while(l1>query[i].l)
add(--l1);
ans1[query[i].org]=ans;
while(l1<l)//回滚还原
del(l1++);
ans=tmp;
}
for(int i=1;i<=q;++i)
printf("%d
",ans1[i]);
return 0;
}
T2 [Violet]蒲公英
题目链接：Link
题目描述：
给定一个长度为 (N) 的序列，有 (M) 次询问，每次询问一个区间 ([l,r]) 的众数是多少。如果有多个数可以作为区间众数，那么输出最小的那一个。输入数据经过加密，强制在线。
Solution：
看到“众数”直接考虑分块就行了。这题强制在线，把莫队也废了，只能考虑普通的分块。
考虑每个询问 ([l,r]) ，设 (l) 属于第 (p) 块，(r) 属于第 (q) 块。分块一般把一段区间 ([l,r]) 分成 3 部分：
- 开头的零散段 ([l,L)) ；
- 中间的由整块构成的段 ([L,R]) ；
- 结尾的零散段 ((R,r]) ；
根据分块“大段维护，局部暴力”的思想，应该重点考虑如何维护 ([L,R]) ，剩下的交给暴力。
在区间求和问题中，分块预处理了每块的区间和。查询时零散段暴力求和，再加上预处理好的区间和，就得到了答案。受此启发，感觉上也可以预处理每块的众数是几。但是区间和可以相加得到更长区间的区间和，也就是区间和满足“可加性”。众数不满足可加性，所以预处理不能只处理每块的众数，要把所有以块的端点为端点的区间 ([L,R]) 的众数预处理出来。
现在考虑零散段暴力。零散段中的元素可能导致最终答案改变，所以还要记下来中间整段中每个元素出现了多少次（开桶，记为 (cnt_{L,R}) ）。直接把两段零散段的元素加入桶中，同时更新众数的值。加入完零散段元素之后得到这次询问的答案。记录答案之后，要把加入的元素再删掉，恢复原来的 (cnt_{L,R}) 的环境，以便下次使用（这不是有点像回滚莫队吗？）。
思路口胡完了，来分析一下时空复杂度吧（设块长为 (T) ）。
- 预处理了 (T) 个块，每个块长度约为 (N) ，预处理时间复杂度 (NT^2) ；
- 零散段长度 (frac N T) ，每次暴力处理，回答询问时间复杂度 (frac {MN} T) ；
- 每一个块内开了长度为 (N) 的桶，空间复杂度 (NT^2) ；
总复杂度 (O(NT^2+frac {NM} T)) ，空间为 (O(NT^2)) 。不妨设 (M,N) 同数量级，得方程：
解得当 (T=sqrt[3] N) 时，算法最快，时间复杂度、空间复杂度都约为 (O(N^{frac 5 3})) 。
Code：
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<iostream>
//using namespace std;
//Online Solve Range Mode Problem
#define ll long long
const int maxn=40005;
template <typename _T>
inline _T const& read(_T &x){
x=0;int f=1;
char ch=getchar();
while(!isdigit(ch)){
if(ch=='-')
f=-1;
ch=getchar();
}
while(isdigit(ch)){
x=(x<<3)+(x<<1)+ch-'0';
ch=getchar();
}
return x*=f;
}
int n,m,len,tot;
int A[maxn],B[maxn];
int bel[maxn],L[maxn],R[maxn];
int cnt[40][40][maxn];//cnt[L][R][0] refers to Range(L,R)'s mode appers times.
int mode[40][40];
int cnt1[maxn];
inline void add(const int _L,const int _R,const int i){//添加一个数，更新当前区间众数和众数出现的次数
cnt[_L][_R][A[i]]++;
mode[_L][_R] = cnt[_L][_R][A[i]] > cnt[_L][_R][0] ? B[A[i]] : mode[_L][_R];
mode[_L][_R] = cnt[_L][_R][A[i]] == cnt[_L][_R][0] && B[A[i]] < mode[_L][_R] ? B[A[i]] : mode[_L][_R];
cnt[_L][_R][0] = cnt[_L][_R][A[i]] > cnt[_L][_R][0] ? cnt[_L][_R][A[i]] : cnt[_L][_R][0];
}
inline void del(const int _L,const int _R,const int i){
cnt[_L][_R][A[i]]--;
}
void Init(){
read(n),read(m);
len=n/pow(n,0.3333333333);
tot=n/len;
// printf("len=%d tot=%d",len,tot);
for(int i=1;i<=tot;++i){
if(i*len>n) break;
L[i]=(i-1)*len+1;
R[i]=i*len;
}
if(R[tot]<n)
tot++,L[tot]=R[tot-1]+1,R[tot]=n;
for(int i=1;i<=n;++i){
bel[i]=(i-1)/len+1;
B[i]=read(A[i]);
}//原题值域较大，需要离散化
std::sort(B+1,B+1+n);
int l=std::unique(B+1,B+n+1)-B-1;
for(int i=1;i<=n;++i)
A[i]=std::lower_bound(B+1,B+1+l,A[i])-B;
//枚举区间L,R，进行预处理
for(int i=1;i<=tot;++i)
for(int j=i;j<=tot;++j){
for(int k=L[i];k<=R[j];++k)
add(i,j,k);
}
int ans;//记录答案众数是多少
signed main(){
Init();
for(int i=1,l0,r0;i<=m;++i){
int l=(read(l0)+ans-1)%n+1,r=(read(r0)+ans-1)%n+1;//加密方式
if(r<l) std::swap(l,r);
int belongL=bel[l]+1,belongR=bel[r]-1;
if(bel[l]==bel[r] || bel[l]+1==bel[r]){//两段相邻或在同一段，直接暴力.
ans=0;
for(int j=l;j<=r;++j){
cnt1[A[j]]++;
ans = cnt1[A[j]] > cnt1[0] ? B[A[j]] : ans;
ans = cnt1[A[j]] == cnt1[0] && B[A[j]] < ans ? B[A[j]] :ans;
cnt1[0] = cnt1[A[j]] > cnt1[0] ? cnt1[A[j]] : cnt1[0];
}//暴力统计，更新区间众数
printf("%d
",ans);
for(int j=l;j<=r;++j)
cnt1[A[j]]--;
cnt1[0]=0;//还原
continue;
}
int tmp1=mode[belongL][belongR];
int tmp2=cnt[belongL][belongR][0];//类似回滚莫队，记录原值
for(int j=l;j<=R[bel[l]];++j)
add(belongL,belongR,j);
for(int j=L[bel[r]];j<=r;++j)
add(belongL,belongR,j);//暴力添加
ans=mode[belongL][belongR];//统计答案
mode[belongL][belongR]=tmp1;//回滚还原
cnt[belongL][belongR][0]=tmp2;
for(int j=l;j<=R[bel[l]];++j)
del(belongL,belongR,j);
for(int j=L[bel[r]];j<=r;++j)
del(belongL,belongR,j);
printf("%d
",ans);
}
return 0;
}
T3 大爷的字符串题
题目链接：Link
题目描述：
给一个长度为 (N) 的序列 (A) ，每次询问一段区间的最大 (rp) 。
(rp) 定义：
每次从区间中任意选择一个数 (x) ，把 (x) 从序列中删除，直到区间为空。要求维护一个集合 (S) 。
- 如果 (S) 为空，则你 (rp) 减 1 。
- 如果 (S) 中有一个数严格大于 (x) ，你 (rp) 减 1 ，清空 (S) 。
- 把 (x) 加入集合 (S) 。
询问之间互不影响，每次询问初始 (rp=0) 。
Solution：
发现第一次选择时，(rp) 一定减 1 ，之后第一条就没用了（之后的 (S) 不可能为空）。
考虑怎么选才能不掉 (rp) 。显然，只要每次选的数严格大于之前的数就行了，也就是说，选出的数应该构成一个严格上升的序列。
如果对要选择的区间从小到大排序，然后从最小的数开始选，相同的数只选一个（保证严格大于，不然会直接掉 (rp) ），一直选到最大的数。这样花费 1 的 (rp) 就把区间中每种数删除了一次。同上方法，从剩下的数种再选一次，又花了 1 的 (rp) 把区间中剩下的每种数删除了一次。这样每次每种数只能删掉一个，那我找找谁最抗删不就行了？
区间众数最抗删，所以要花费区间众数出现次数的 (rp) 删掉区间中所有数。
答案即为 T1 答案的相反数，代码不给了。