浅谈分块 区间众数

已于 2022-02-14 12:39:08 修改
阅读量378 收藏 2
点赞数 3
分类专栏： OI 文章标签： 算法 数据结构
于 2021-09-18 00:04:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50332374/article/details/120358973
版权

前言

分块大法好（

本文直接讲例题了 qwq

文章目录

P4168 [Violet]蒲公英

题目链接：P4168 [Violet]蒲公英

题意: 找到区间内编号最小的众数，强制在线

解法一

直接分块

设块长为 l e n len len ，块的总数为 t t t 个

我们先预处理出所有以块的端点为端点的区间众数和众数的出现次数

或者说就是把每个连续块组成的区间都算出编号最小众数和它的出现次数

别忘了离散化，不然MLE咯

总共有 t 2 t^2 t2 个这样的区间，每次处理 O ( n ) O(n) O(n) ，则预处理时间复杂度为 O ( n t 2 ) O(nt^2) O(nt2)

暴力查询时可以在预处理过的数组基础上临时更新数组，以统计答案，再复原数组

总时间复杂度 O ( n t 2 + m n / t ) O(nt^2+mn/t) O(nt2+mn/t)

假设 m m m 和 n n n 数量级相同，解 n t 2 = m n / t nt^2=mn/t nt2=mn/t， t ≈ n 3 t \approx \sqrt[3]{n} t≈3n ​

则时间复杂度可以控制在 O ( n 5 / 3 ) O(n^{5/3}) O(n5/3) 内

空间复杂度比较大， O ( n t 2 ) O(nt^2) O(nt2) （注：预处理所需）

代码如下

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define MAXN (int)(5e4+5)
#define MAXM (int)(45)
#define pc(a) putchar(a)
template<typename T>inline void read(T &k)
{
	char ch=getchar();T x=0,f=1;
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch)){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
	k=x*f;
}
template<typename T>void write(T k)
{
	if(k<0){pc('-');k=-k;}
	if(k>9)write(k/10);
	pc(k%10+'0');
}
int n,m,Q,len,last,t;
int id[MAXN],L[MAXN],R[MAXN],c[MAXM][MAXM][MAXN]; // c[i][j][a[k]] 表示块i~j中a[k]的出现次数
int b[MAXN],f[MAXM][MAXM][2],now[2],a[MAXN]; // f[i][j][0/1]分别记录次数和众数
void init()
{
    // 预处理
	sort(b+1,b+1+n);
	m=unique(b+1,b+1+n)-b-1;
	for(int i=1; i<=n; i++)
		a[i]=lower_bound(b+1,b+1+m,a[i])-b; // 离散化
	t=pow((double)n,(double)1/3); // 块的数量
	len=t?n/t:n; // 块的长度
	for(int i=1; i<=t; i++)
	{
		L[i]=(i-1)*len+1;
		R[i]=i*len;
	}
	if(R[t]<n)
	{
		L[t+1]=R[t]+1;
		R[++t]=n;
	}
	for(int i=1; i<=t; i++)
		for(int j=L[i]; j<=R[i]; j++)
			id[j]=i;
	for(int i=1; i<=t; i++)
		for(int j=i; j<=t; j++)
		{
			for(int k=L[i]; k<=R[j]; k++)
				++c[i][j][a[k]]; // 统计答案
			for(int k=1; k<=m; k++)
			{
				if(c[i][j][k]>f[i][j][0]) // 更新答案
				{
					f[i][j][0]=c[i][j][k];
					f[i][j][1]=k;
				}
			}
		}
}
void proc(int x,int y,int k)
{
	++c[x][y][k]; // 临时修改
	if(c[x][y][k]>now[0]||c[x][y][k]==now[0]&&k时间<now[1])
	{
		now[0]=c[x][y][k]; // 更新答案
		now[1]=k;
	}
}
void solve(int l,int r)
{
	l=(l+last-1)%n+1; // 题目要求
	r=(r+last-1)%n+1;
	if(l>r)swap(l,r); // 题目要求

	int p=id[l],q=id[r],x=0,y=0;
	if(p+1<=q-1)x=p+1,y=q-1;
	memcpy(now,f[x][y],sizeof(now));
	if(p==q)
	{
		for(int i=l; i<=r; i++)proc(x,y,a[i]); // 临时修改+更新答案
		for(int i=l; i<=r; i++)--c[x][y][a[i]]; // 改回来
	}else
	{
		for(int i=l; i<=R[p]; i++)proc(x,y,a[i]);
		for(int i=L[q]; i<=r; i++)proc(x,y,a[i]);
		for(int i=l; i<=R[p]; i++)--c[x][y][a[i]];
		for(int i=L[q]; i<=r; i++)--c[x][y][a[i]];
	}
	write(last=b[now[1]]);pc('\n');
}
signed main()
{
	read(n);read(Q);
	for(int i=1; i<=n; i++)
		read(a[i]),b[i]=a[i];
	init();
	while(Q--)
	{
		int l,r;
		read(l);read(r);
		solve(l,r);
	}
	return 0;
}

解法二

还是分块，只不过维护的东西不一样

我们发现，解法一的空间就多在了次数统计这个东西上

次数统计？不是可以二分吗？

对每个数值建个vector保存它出现的下标，出现次数就是upper_bd-lower_bd

这样我们只要预处理众数是谁就行了

暴力查询结果和众数的结果比一下就行了

别忘了离散化哦

有点时间换空间的感觉，但是还是很快

时间复杂度 O ( n t + m n / t × log ⁡ n ) O(nt+mn/t\times \log n) O(nt+mn/t×logn)

假设 m m m 和 n n n 数量级相同，还是解方程， t ≈ n log ⁡ n t \approx \sqrt{n\log n} t≈nlogn ​

则时间复杂度可控制在 O ( n n log ⁡ n ) O(n\sqrt{n\log n}) O(nnlogn ​)

空间复杂度 O ( t 2 ) O(t^2) O(t2) ，不错

代码如下

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define MAXN (int)(5e4+5)
#define MAXM (int)(888)
#define pc(a) putchar(a)
template<typename T>inline void read(T &k)
{
	char ch=getchar();T x=0,f=1;
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch)){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
	k=x*f;
}
template<typename T>void write(T k)
{
	if(k<0){pc('-');k=-k;}
	if(k>9)write(k/10);
	pc(k%10+'0');
}
int n,m,Q,last,t,len,c[MAXN],id[MAXN];
int a[MAXN],b[MAXN],L[MAXM],R[MAXM],f[MAXM][MAXM];
vector<int> vec[MAXN];
int find(int k,int l,int r)
{
	return upper_bound(vec[k].begin(),vec[k].end(),r)
	-lower_bound(vec[k].begin(),vec[k].end(),l);
} // 出现次数
void proc(int k,int l,int r,int &ans,int &cnt)
{
	int res=find(k,l,r);
	if(res>cnt||res==cnt&&k<ans)
	{
		cnt=res;
		ans=k;
	} // 更新答案
}
void init()
{
	sort(b+1,b+1+n);
	m=unique(b+1,b+1+n)-b-1;
	for(int i=1; i<=n; i++)
	{
		a[i]=lower_bound(b+1,b+1+m,a[i])-b;
		vec[a[i]].push_back(i); // 记录下标
	}
	t=sqrt(log(n)/log(2)*n);
	len=t?n/t:n;
	for(int i=1; i<=t; i++)
	{
		L[i]=(i-1)*len+1;
		R[i]=i*len;
	}
	if(R[t]<n)
	{
		L[t+1]=R[t]+1;
		R[++t]=n;
	}
	for(int i=1; i<=t; i++)
		for(int j=L[i]; j<=R[i]; j++)
			id[j]=i;
	for(int i=1; i<=t; i++)
	{
		memset(c,0,sizeof(c)); // 统计次数
		int cnt=0,ans=0;
		for(int j=L[i]; j<=n; j++)
		{
			++c[a[j]];
			if(c[a[j]]>cnt||c[a[j]]==cnt&&a[j]<ans)
			{
				cnt=c[a[j]];
				ans=a[j];
			}
			f[i][id[j]]=ans; // 众数
		}
	}
}
void solve(int l,int r)
{
	l=(l+last-1)%n+1;
	r=(r+last-1)%n+1;
	if(l>r)swap(l,r);
	int p=id[l],q=id[r],x=0,y=0,ans=0,cnt=0;
	if(p+1<=q-1)x=p+1,y=q-1;
	if(p==q)
	{
		for(int i=l; i<=r; i++)
			proc(a[i],l,r,ans,cnt);
	}else
	{
		for(int i=l; i<=R[p]; i++)proc(a[i],l,r,ans,cnt);
		for(int i=L[q]; i<=r; i++)proc(a[i],l,r,ans,cnt);
	}
	if(f[x][y])proc(f[x][y],l,r,ans,cnt);
	write(last=b[ans]);pc('\n');
}
signed main()
{
	read(n);read(Q);
	for(int i=1; i<=n; i++)
		read(a[i]),b[i]=a[i];
	init();
	while(Q--)
	{
		int l,r;
		read(l);read(r);
		solve(l,r);
	}
	return 0;
}

然后我们就想到

如果只需要知道众数的出现次数，有没有什么好的办法呢？

[Ynoi2019 模拟赛] Yuno loves sqrt technology III

题目链接：[Ynoi2019 模拟赛] Yuno loves sqrt technology III

题意：区间众数出现次数，强制在线

类似于上一题的解法二，这题 t = n t=\sqrt{n} t=n ​ 即可

不同的是，我们要预处理出连续块的众数出现次数

然后还是每个数值建一个vector，统计出现的下标

再记录每个存的下标在vector中的下标 a x i ax_i axi​

显然非暴力查询的区域，答案 r e s = f [ x ] [ y ] res=f[x][y] res=f[x][y]

因为边界数最多对答案有 2 n 2\sqrt{n} 2n ​ 的贡献

所以暴力查询时，对于每个左侧元素 k k k ，我们只要找到 k k k 的vector中 a x k + r e s ax_k+res axk​+res 的位置的元素，看它是不是小于 r r r ，如果小于 r r r ，说明它一定更接近最终答案且在该区间内，更新 r e s res res

对于每个右侧元素 k k k ，我们只要找到 k k k 的vector中 a x k − r e s ax_k-res axk​−res 的位置的元素，看它是不是大于 l l l ，原理同上

最终答案即为 r e s res res

时间复杂度 O ( ( n + m ) n ) O((n+m)\sqrt{n}) O((n+m)n ​)

空间复杂度 O ( n ) O(n) O(n)

代码如下

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define MAXN (int)(5e5+5)
#define MAXM (int)(888)
#define pc(a) putchar(a)
template<typename T>inline void read(T &k)
{
	char ch=getchar();T x=0,f=1;
	while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(isdigit(ch)){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
	k=x*f;
}
template<typename T>void write(T k)
{
	if(k<0){pc('-');k=-k;}
	if(k>9)write(k/10);
	pc(k%10+'0');
}
int n,m,Q,last,t,len,c[MAXN],id[MAXN],cnt[MAXN];
int a[MAXN],b[MAXN],L[MAXM],R[MAXM],f[MAXM][MAXM],ax[MAXN];
vector<int> vec[MAXN];
void init()
{
	sort(b+1,b+1+n);
	m=unique(b+1,b+1+n)-b-1;
	for(int i=1; i<=n; i++)
	{
		a[i]=lower_bound(b+1,b+1+m,a[i])-b; // 离散化
		vec[a[i]].push_back(i); // 下标
		ax[i]=vec[a[i]].size()-1; // 每个下标在vector中的下标
	}
	t=sqrt(n);
	len=t?n/t:n;
	for(int i=1; i<=t; i++)
	{
		L[i]=(i-1)*len+1;
		R[i]=i*len;
	}
	if(R[t]<n)
	{
		L[t+1]=R[t]+1;
		R[++t]=n;
	}
	for(int i=1; i<=t; i++)
		for(int j=L[i]; j<=R[i]; j++)
			id[j]=i;
	for(int i=1; i<=t; i++)
	{
		memset(c,0,sizeof(c));
		for(int j=i; j<=t; j++)
		{
			f[i][j]=f[i][j-1];
			for(int k=L[j]; k<=R[j]; k++)
				f[i][j]=max(++c[a[k]],f[i][j]); 
				// 统计次数即可（它又不要知道众数是谁咯 qwq）
		}
	}
}
void solve(int l,int r)
{
	l^=last;r^=last; // 题目要求
	if(l>r)swap(l,r);
	int p=id[l],q=id[r],x=0,y=0,res=0;
	if(p+1<=q-1)x=p+1,y=q-1;
	if(p==q)
	{
		for(int i=l; i<=r; i++)
			cnt[a[i]]=0;
		for(int i=l; i<=r; i++)
			res=max(++cnt[a[i]],res);
	}else
	{
		res=f[x][y];
		for(int i=l; i<=R[p]; i++)
		{
			int it=ax[i]+res;
			while(it<vec[a[i]].size()&&vec[a[i]][it]<=r)
				{++res;++it;} // 暴力扩展+更新答案
		}

		for(int i=L[q]; i<=r; i++)
		{
			int it=ax[i]-res;
			while(it>=0&&vec[a[i]][it]>=l)
				{++res;--it;}
		}
	}
	write(last=res);pc('\n');
}
signed main()
{
	read(n);read(Q);
	for(int i=1; i<=n; i++)
		read(a[i]),b[i]=a[i];
	init();
	while(Q--)
	{
		int l,r;
		read(l);read(r);
		solve(l,r);
	}
	return 0;
}

总结

本文简单讲了下区间众数的分块解法

转载请说明出处

q779
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
众数问题详解.zip说明
03-28
在数据分析领域，众数是一个非常重要的统计概念，它表示数据集中出现次数最多的数值。众数问题的探讨往往与数据分布的特性紧密相关，因为它能够揭示数据的集中趋势。然而，众数并不总是能够全面地描绘整个数据集的...
BZOJ 2724 浅谈分块算法求区间众数
BerryKanry的博客
07-20 4453
世界真的很大 分块算法大概算是一种在线的数据结构，和线段树作用差不多，但是却能维护一些线段树维护不了的信息。 线段树要求维护的信息必须要具备可合并性，就是说子区间的信息能够合并到大区间里，比如区间和，区间值域等 但是分块却不需要这样的条件 有点暴力的味道但是确确实实是一种有效的数据结构 看题先： description： input 修正一下l = (l_0 + x - 1) m
近期总结2
jz_terry的博客
12-11 303
莫队:https://www.cnblogs.com/WAMonster/p/10118934.html 使用条件:查询连续一段区间,且扩张或缩小区间两端的复杂度优秀. 做法:离线,把序列分块,把L,R按所在块的编号从小到大双关键字排序.每次移动查询. 优化:排序时l递增,在l的块为奇数时R递增,为偶数时R递减. 带修莫队:加入一个修改的时间戳,也作为关键字排序,然后分的块大小为n^(3/...
【莫队】区间众数（Codeforces Round #716 (Div. 2) D）
tzs1328540878的博客
04-24 1349
D. Cut and Stick （赛后补题）借本题学习莫队算法以及区间众数的求法 题意：对于整型数组，每次询问[L,R][L,R][L,R]区间问最少分为多少个子序列，使得每个子序列的众数xxx的个数cntxcnt_xcntx​不大于 ⌈len2⌉\left \lceil \frac{len}{2} \right \rceil⌈2len​⌉，lenlenlen表示子序列的长度 思路：对于每次询问只需知道询问区间内的众数xxx的个数即可，最优解即为将其余的非众数尽可能与更多的xxx组合为一个子序列，而剩下
区间众数
Rookie的博客
07-26 9113
一、块状数组 块状数组就是将数组划分若干块（一般为sqrt（n）使复杂度最低），通过预处理i~j块的答案（复杂度可以保证在n*sqrt（n）内）， 求答案时就根据预处理的答案和暴力枚举首尾多余个数得出最后答案，首尾多余的个数是不超过2*sqrt（n），这样总的复杂度 为（（n+q）sqrt（n）），q为查询的次数。 二、区间众数 1.题目描述 有n个数x,查询q次，求【L，R】区间的众
区间众数（主席树+分块）
lcl1234567890lcl的博客
07-22 1231
P4168 [Violet]蒲公英 众所周知，线段树不可用于区间反转，区间众数 这个题最先思考的是建一颗主席树，由于有权值线段树的影子在里面，所以就有一个简单的思路： 查询的时候想办法找区间内出现最多的数，主席树的查询，恰好可以，求到出现次数，但是如何找到出现的次数又成了新的问题，加之还要求最小的众数，又构成了新的问题 最早的想法是二分，但是后来发现问题不具有单调性，所以pass 想了很久，最后还是妥协了，还是要用分块 简单的说，是要进行预处理,即处理每两个块之间的众数，时间复杂度O(n1.5)。 查询：
分块入门9 --- 区间众数
weixin_30521649的博客
07-23 214
????‍⚕️????‍????????‍♀️ //写完入门后，这道一直想补，终于拖到了现在d=====(￣▽￣*)b 分块维护每一块的众数（第i块到第j块的众数），所以中间的块预处理就可以得到，旁边的块我们暴力枚举，但这样前面预处理得到的还需要统计它出现次数。这个我们就可以用到二分来找，找中间块最多的那个数，二分找在[x,y]内出现次数，所以我们就需要一个数组来保存某个数所有的出现位置，边界块的每一个数也...
众数问题详解0.zip
03-28
众数问题在计算机科学，尤其是数据挖掘和统计分析领域中占据着重要的地位。众数是数据集中出现次数最多的数值，可以是单个数值或一组数值。在无限制的整数集合中，众数可能不存在（如果所有数字出现次数相同），也...
众数2问题详解.zip
03-28
在计算机科学和算法设计中，"众数"是指在一组数据中出现次数最多的数值。众数问题是一个常见的数据处理和数据分析任务，特别是在大数据和统计学领域。本篇将深入探讨众数问题及其解决方案，旨在帮助读者理解如何在...
众数问题详解1.zip
03-28
众数问题在计算机科学和数据分析领域中是一个常见且重要的议题，尤其在算法设计和数据挖掘中扮演着关键角色。众数是指在一组数据中出现次数最多的数值，它并不一定唯一，也可能不存在。在这个主题中，我们将深入探讨...
3众数问题详解.zip
最新发布
03-28
在IT领域，众数问题是一个常见的数据处理与分析任务，特别是在统计学和计算机科学中。众数是指在一组数据中出现次数最多的数值，它不一定是唯一的，也可能不存在。众数问题通常涉及到查找一个数据集中的主要趋势或者...
区间众数（分块）
jpphy0的博客
07-18 1598
目录问题分析代码 问题 n个数构成一个序列，查询 [L,R][L, R][L,R] 区间内出现次数最多的那个数的出现次数。时间、空间复杂度要求均为：O(n⋅n)O(n\cdot \sqrt{n})O(n⋅n​)。 分析 基本思想：分块 离散化，使得序列元素ana_nan​ 转换成 an′∈[1,n]a_n^{'} \in [1, n]an′​∈[1,n] 计算块 i、ji、ji、j 间的最大次数，用 f[i][j]f[i][j]f[i][j] 记录 计算元素 an′a_n^{'}an′​ 在前 iii 块
数列分块求区间众数（学习笔记）
qq_35160381的博客
05-17 2808
数列分块 1. 区间加法，区间求和 简单分析一下：将数列划分为n−−√n\sqrt{n}个块，对于区间修改，整块的进行atag标记一下，非整块的最多只有2n−−√2n2\sqrt n个，暴力加一下 复杂度：O(n−−√)O(n)O(\sqrt n) #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cmath&gt...
分块入门9:P4168 区间众数查询O(n*sqrt(n))
H_ang的博客
07-11 294
题目链接：https://www.luogu.org/problemnew/show/P4168 题目大意： 思路一： 在线区间众数的分块做法比较多，这里提供一个思路： 首先离散化一下比较方便。 可以推导出：[L, R]的众数一定是整数块的众数，或者两个边块的数。 所以对于每次查询，众数的可能值最多有2sqrt(n)+1个 所以我们可以预处理f(i,j)表示第 i 块到第 j 块的众数（枚举 ...
区间众数、蒲公英（分块思想）
一名蒟蒻的博客
11-09 356
区间众数（分块思想） 题目链接：蒲公英 题目大意：给一个数组，q次在线查询，每次查询L-R中出现次数最多且最小的数。 解题思路： 首先我们把这个数组分为k块来看待，然而每次查询的L-R则有几种可能，如下图 ...
分块9：求区间众数（若存在多个众数，输出值最小的）
Destiny
08-16 2803
  警戒：以后类似于没看到强制在线这种傻逼错误千万不要犯啊。     问题描述： 在乡下的小路旁种着许多蒲公英，而我们的问题正是与这些蒲公英有关。 为了简化起见，我们把所有的蒲公英看成一个长度为n的序列 (a_1,a_2..a_n)(a1​,a2​..an​) ，其中 a_iai​ 为一个正整数，表示第i棵蒲公英的种类编号。 而每次询问一个区间 [l,r]，你需要回答区间里出现次数最...
【分块】区间众数
weixin_30701575的博客
11-17 300
关于分块求众数可以看黄学长写的蒲公英题解 链接：http://hzwer.com/3582.html 【题目大意】 总共有n个数，m个询问，对于每个询问[l，r]求出区间内众数的出现次数 1<=n<=10000,1<=m<=20000 【做法】 我当时还不会莫队只能用分块来做......结果学长说这是莫队模板题比较尴尬 首先先离散化处理一下【不然咋做我不会啊】...
区间众数，分块
xizi_ghq的博客
10-28 159
第一次过了一个洛谷黑题，区间众数 洛谷：4168 代码： #include<bits/stdc++.h> using namespace std; using ll =long long; const int M=4e4+5,K=210; struct Node{ll num,val;}p[K][K],e; ll d[M],n,m,blo,L[K],R[K],B[M],sum[...
LOJ---6285：数列分块入门 9【区间众数】
KobeDuu
03-29 863
题目： https://loj.ac/problem/6285 分析： 如果只查询众数的个数，完全可以莫队，加数时容易维护众数的数量，删除数时，众数的数量要么减1，要么不变，只需再开一个标记数组维护众数的数量即可 根据陈立杰---《区间众数解题报告》实现了下面两种解法 解法一： 块数分成sqrt(n)超时了，150可以过（分块真毒瘤） #pragma GCC optimize(2)...
pytorch 众数
09-01
PyTorch没有直接提供计算众数的函数。要计算众数，可以先使用torch.flatten()将张量展平为一维数组，然后使用torch.mode()函数找到最常出现的元素。下面是一个例子代码可以计算PyTorch张量的众数： import torch #...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值