分块

最新推荐文章于 2024-07-16 18:11:29 发布
最新推荐文章于 2024-07-16 18:11:29 发布
阅读量98 收藏 1
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41499541/article/details/113993364
版权

分块

分块八：询问等于一个数 c 的元素，并将这个区间的所有元素改为 c

维护每个分块是否有统一的值 num[],如果有，块的时间是o(1)，否则暴力

//AC代码
#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int n,t,ans;
int l[N],r[N],pos[N],siz[N],a[N],vis[N],zhi[N];
void kuai(){
    t=sqrt(n);
    for(int i=1;i<=t;i++){
        l[i]=(i-1)*t+1;
        r[i]=i*t;
        siz[i]=t;
    }
    if(r[t]<n){
        t++;
        l[t]=r[t-1]+1;
        r[t]=n;
        siz[t]=n-r[t-1];
    }
    for(int i=1;i<=t;i++)
        for(int j=l[i];j<=r[i];j++)
            pos[j]=i;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    kuai();
    int ll,rr,L,R,c;
    for(int i=1;i<=n;i++){
        scanf("%d%d%d",&ll,&rr,&c);
        L=pos[ll];R=pos[rr];ans=0;
        if(L==R){
            if(!vis[L]){
                for(int j=ll;j<=rr;j++){
                    if(a[j]==c) ans++;
                    else a[j]=c;                
                }
            }
            else{
                if(zhi[L]==c) ans+=rr-ll+1;
                else{
                    if(ll==l[L]&&rr==r[R]) zhi[L]=c;
                    else{
                        vis[L]=0;
                        for(int j=ll;j<=rr;j++)
                            a[j]=c;
                        for(int j=l[L];j<ll;j++)
                            a[j]=zhi[L];
                        for(int j=rr+1;j<=r[R];j++)
                            a[j]=zhi[R];
                    }
                }
            }
        }
        else{
            for(int j=L+1;j<=R-1;j++){
                if(!vis[j]){
                    for(int k=l[j];k<=r[j];k++){
                        if(a[k]==c) ans++;
                        else a[k]=c;
                    }
                    vis[j]=1;zhi[j]=c;
                }
                else{
                    if(zhi[j]==c) ans+=siz[j];
                    else zhi[j]=c;
                }
            }
            if(!vis[L]){
                for(int j=ll;j<=r[L];j++){
                    if(a[j]==c) ans++;
                    else a[j]=c;
                }
            }
            else{
                if(zhi[L]==c) ans+=r[L]-ll+1;
                else{
                    vis[L]=0;
                    for(int j=ll;j<=r[L];j++)
                        a[j]=c;
                    for(int j=l[L];j<ll;j++)
                        a[j]=zhi[L];
                }
            }
            if(!vis[R]){
                for(int j=l[R];j<=rr;j++){
                    if(a[j]==c) ans++;
                    else a[j]=c;
                }
            }
            else{
                if(zhi[R]==c) ans+=rr-l[R]+1;
                else{
                    vis[R]=0;
                    for(int j=l[R];j<=rr;j++)
                        a[j]=c;
                    for(int j=rr+1;j<=r[R];j++)
                        a[j]=zhi[R];
                }
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

//代码有锅
#include<bits/stdc++.h>
using namespace std;
#define MAXN 100010
int a[MAXN],l[1010],r[1010],num[1010],pos[MAXN],n,x,y,z,m;
//num表示当前块是否有统一值 
int main()
{
	scanf("%d",&n);
	m=sqrt(n);
	for(int i=1;i<=n;i++)//初始分块 
	{
		scanf("%d",&a[i]);
		pos[i]=(i-1)/m+1;
		l[pos[i]]=min(l[pos[i]],i);
		r[pos[i]]=max(r[pos[i]],i);
	}
	int k=n;
	while(k--)
	{
		scanf("%d%d%d",&x,&y,&z);
		int ans=0;
		if(pos[y]-pos[x]<=1)
		{
			for(int i=x;i<=y;i++)
			{
				if(a[i]==z) ans++;
				a[i]=z;
			}
		
		}
		else
		{
			for(int i=pos[x]+1;i<=pos[y]-1;i++)
			{
				if(num[i]==z) ans+=r[i]-l[i]+1;
				else if(!num[i])
				{
					for(int i=l[i];i<=r[i];i++)
					{
						if(a[i]==z) ans++;
						a[i]=z;
					}
				}
				num[i]=z;
			}
			//左残缺块 
			if(num[pos[x]]==z)
			{
				ans+=r[pos[x]]-x+1;
			}
			else
			{
				if(num[pos[x]])//修改l之前的值 
					for(int i=l[pos[x]];i<=x-1;i++)
					{
						a[i]=num[pos[x]]; 
					}
				for(int i=x;i<=r[pos[x]];i++)
					{
						if(a[i]==z) ans++;
						a[i]=z;
					}
				num[pos[x]]=0; 
			}
			//右残缺块 
			if(num[pos[y]]==z)
			{
				ans+=y-l[pos[y]]+1;
			}
			else
			{
				if(num[pos[y]])//修改l之前的值 
					for(int i=y+1;i<=r[pos[y]];i++)
					{
						a[i]=num[pos[y]]; 
					}
				for(int i=y;i>=l[pos[y]];i--)
					{
						if(a[i]==z) ans++;
						a[i]=z;
					}
				num[pos[y]]=0;
			}
		}
		printf("%d\n",ans);
	}
	return 0;
}

分块九：区间众数 （P4168 [Violet]蒲公英）

洛谷题解：https://www.luogu.com.cn/problem/solution/P4168

首先暴力统计区间众数的时间复杂度为接近O(n^2)，时间复杂度不够优秀，所以我们 遇事不决先分块考虑分段处理。数据范围比较大，所以我们离散化。所谓离散化就是将数据排好序后用ta的排名来代替ta本身（需要另开一个数组）。nlog(n)时间内就能完成。

void yych()//离散化 
{
	len=sqrt(n);
	memset(L,0x3f,sizeof(L));
	for(int i=1;i<=n;++i)
	{
		pos[i]=(i-1)/len+1;
		L[pos[i]]=min(L[pos[i]],i);
		R[pos[i]]=max(R[pos[i]],i);
		a[i]=read();
		b[i]=a[i];	
	}
	sort(b+1,b+1+n);
	tot=unique(b+1,b+1+n)-b-1;
	for(int i=1;i<=n;++i)a[i]=lower_bound(b+1,b+1+tot,a[i])-b;
}

然后我们考虑分块预处理。我们首先可以处理出每个数字在块中出现次数的前缀和。枚举每一个数是O(n),枚举每一个块时间是O( n \sqrt{n} n ​)),所以总的时间就是O(n n \sqrt {n} n ​)。然后我们还可以处理出从第l个块到第r个块的区间众数。我们枚举l的复杂度是O( n \sqrt {n} n ​),枚举r的复杂度是O( n \sqrt {n} n ​),然后枚举块内每一个数的时间复杂度也是O( n \sqrt {n} n ​),总共就是O(n( n \sqrt {n} n ​))

其中非常重要的就是

void Treaker()//分块预处理 
{
	for(int i=1;i<=n;++i)
	for(int j=pos[i];j<=pos[n];++j)s[j][a[i]]++;
	
	for(int i=1;i<=pos[n];++i)
	{
		memset(tong,0,sizeof(tong));
		for(int j=i;j<=pos[n];++j)
		{
			p[i][j]=p[i][j-1];
			for(int k=L[j];k<=R[j];++k)
			{
				tong[a[k]]++;
				if((tong[a[k]]>tong[p[i][j]])||(tong[a[k]]==tong[p[i][j]]&&a[k]<p[i][j]))p[i][j]=a[k];
			}
		}
	}
	memset(tong,0,sizeof(tong));
}

其中非常重要的就是

p[i][j]=p[i][j-1];

因为我们首先需要继承原先的区间众数，然后才能够比较更新。否则的话就会 听取WA声一片,我就是有很多次挂在这里的 TAT.
然后就是询问操作，我们根据分块直觉，就应该是残块暴力搞，整块骚操作。所以我们对于 p o s r − p o s l ≤ 2 pos_r- pos_l \le2 posr​−posl​≤2的情况直接暴力就OK了。

	if(pos[r]-pos[l]<=2)
	{
		int res=0;
		for(int i=l;i<=r;++i)
		{
			++tong[a[i]];
			if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
		}
		for(int i=l;i<=r;++i)tong[a[i]]=0;
		return res;
	}

对于其他的情况，我们知道我们所求的答案，要么是整块里的众数，要么是残块里的数字。对于残块里的数字，以为我们之前已经处理过了整块的数字出现的前缀和，所以我们能统计出残块中的数字在询问区间里的出现次数。对于整块中的众数，我们也能在 O ( n ) O ( n ) O(\sqrt n)O( n) O(n ​)O(n)复杂度内统计出 ta在残块中的出现次数。这样我们就能得到我们询问区间里众数。

	int res=0;
	for(int i=l;i<=R[pos[l]];++i)if(!tong[a[i]])tong[a[i]]+=s[pos[r]-1][a[i]]-s[pos[l]][a[i]];
	for(int i=L[pos[r]];i<=r;++i)if(!tong[a[i]])tong[a[i]]+=s[pos[r]-1][a[i]]-s[pos[l]][a[i]];
	for(int i=l;i<=R[pos[l]];++i)
	{
		++tong[a[i]];
		if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
	}
	for(int i=L[pos[r]];i<=r;++i)
	{
		++tong[a[i]];
		if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
	}
	int k=p[pos[l]+1][pos[r]-1];
	int lin=s[pos[r]-1][k]-s[pos[l]][k];
	for(int i=l;i<=R[pos[l]];++i)lin+=(a[i]==k);
	for(int i=L[pos[r]];i<=r;++i)lin+=(a[i]==k);
	if(lin>tong[res]||(lin==tong[res]&&k<res))res=k;
	for(int i=l;i<=R[pos[l]];++i)tong[a[i]]=0;
	for(int i=L[pos[r]];i<=r;++i)tong[a[i]]=0;
	return res;

还有一点就是我们在统计每个数字出现的次数的时候我们需要开一个桶数组，我们每次用完了之后不用全部清空，只用将我们使用过的清空一下就可以啦。实测可以省掉很大的时间。
最后说一下注意事项：
1.注意离散化，否则直接RE到原地起飞。
2.注意p数组的转移，否则WA到怀疑人生。
3.注意分块的边界，否则TLE到直接原地爆炸。

最后献上窝丑陋的代码：

#include<bits/stdc++.h>
using namespace std;
int n,m,tot,len,l,r,ans;
const int N=40010,M=50010,K=510;
int a[N],b[N],pos[N],s[K][N],L[K],R[K],p[K][K],tong[N];
int read()
{
	char ch;int x=0,f=1;
	while(!isdigit(ch=getchar()))
	{(ch=='-')&&(f=-f);}
	while(isdigit(ch))
	{x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    return x*f;
}
int cnt=0;
void yych()//离散化 
{
	len=sqrt(n);//分成根号n块 
	memset(L,0x3f,sizeof(L));
	for(int i=1;i<=n;++i)
	{
		pos[i]=(i-1)/len+1;//第i个元素所在的块 
		L[pos[i]]=min(L[pos[i]],i);//每块的左端点 
		R[pos[i]]=max(R[pos[i]],i);
		a[i]=read();
		b[i]=a[i];	//离散化数组 
	}
	sort(b+1,b+1+n);
	tot=unique(b+1,b+1+n)-b-1;
	for(int i=1;i<=n;++i)a[i]=lower_bound(b+1,b+1+tot,a[i])-b;
}
void Treaker()//分块预处理 
{
	for(int i=1;i<=n;++i)
	for(int j=pos[i];j<=pos[n];++j)
			s[j][a[i]]++;//类似于前缀和数组，第j块的a[i]++，因为是前缀和，后面的块都需要加 
	//p[i][j]表示i到j块的众数 
	for(int i=1;i<=pos[n];++i)
	{
		memset(tong,0,sizeof(tong));//i变化后，桶内元素重置 
		for(int j=i;j<=pos[n];++j)
		{
			p[i][j]=p[i][j-1];//继承上一个 
			for(int k=L[j];k<=R[j];++k)//统计第j块 
			{
				tong[a[k]]++;
				//更优的情况 
				if((tong[a[k]]>tong[p[i][j]])||(tong[a[k]]==tong[p[i][j]]&&a[k]<p[i][j]))p[i][j]=a[k];
			}
		}
	}
	memset(tong,0,sizeof(tong));
}
int ask(int l,int r)
{
	if(pos[r]-pos[l]<=2)//区间没有完整块的情况，暴力 
	{
		int res=0;
		for(int i=l;i<=r;++i)
		{
			++tong[a[i]];
			if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
		}
		for(int i=l;i<=r;++i)tong[a[i]]=0;//注意清零 
		return res;
	}
	//有完整块的情况 ，分成残缺块和完整块两种情况。 
	int res=0;
	//如果桶内无元素，则把残缺块的元素要加上完整块的个数 
	for(int i=l;i<=R[pos[l]];++i)if(!tong[a[i]])tong[a[i]]+=s[pos[r]-1][a[i]]-s[pos[l]][a[i]];//前缀和 
	for(int i=L[pos[r]];i<=r;++i)if(!tong[a[i]])tong[a[i]]+=s[pos[r]-1][a[i]]-s[pos[l]][a[i]];
	for(int i=l;i<=R[pos[l]];++i)//左残缺块 
	{
		++tong[a[i]];
		if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
	}
	for(int i=L[pos[r]];i<=r;++i)//右残缺块
	{
		++tong[a[i]];
		if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
	}
	int k=p[pos[l]+1][pos[r]-1];//完整块的众数 
	int lin=s[pos[r]-1][k]-s[pos[l]][k];//完整块的众数个数 
	for(int i=l;i<=R[pos[l]];++i)lin+=(a[i]==k);//k需要加上残缺块 
	for(int i=L[pos[r]];i<=r;++i)lin+=(a[i]==k);
	if(lin>tong[res]||(lin==tong[res]&&k<res))res=k;
	
	for(int i=l;i<=R[pos[l]];++i)tong[a[i]]=0; //清零 
	for(int i=L[pos[r]];i<=r;++i)tong[a[i]]=0;
	return res;
}
int main()
{
	cin>>n>>m;
	yych();
	Treaker();
	for(int i=1;i<=m;++i)
	{
		l=read();r=read();
		l=(l+ans-1)%n+1;r=(r+ans-1)%n+1;
		if(l>r)swap(l,r);
		ans=b[ask(l,r)];
		printf("%d\n",ans);
	}
	return 0;
}
ltlti
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
分块查找
qq_36314864的博客
06-03 7513
分块查找又称索引顺序查找，它吸取了顺序查找和折半查找各自的优点，既有动态结构，又适于快速查找。 分块查找的基本思想：将查找表分为若干子块。块内的元素可以无序，但块之间是有序的，即第一个块中的最大关键字小于第二个块中的所有记录的关键字，第二个块中的最大关键字小于第三个块中的所有记录的关键字，以此类推。再建立-一个索引表，索引表中的每个元素含有各块的最大关键字和各块中的第一个元素的地址，索引表按关键字有序排列。 分块查找的过程分为两步:第一步是在索引表中确定待查记录所在的块，可以顺序查找或折半查找索引表;第二步
分块最好的ppt
10-19
分块最好的ppt。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
bzoj 3781: 小B的询问
lqybzx的专栏
12-06 805
Description 小B有一个序列，包含N个1~K之间的整数。他一共有M个询问，每个询问给定一个区间[L..R]，求Sigma(c(i)^2)的值,其中i的值从1到K，其中c(i)表示数字i在[L..R]中的重复次数。小B请你帮助他回答询问。 Input 第一行，三个整数N、M、K。 第二行，N个整数，表示小B的序列。 接下来的M行，每行两个整数L、R。 O
分块⑨题
weixin_34075268的博客
12-26 161
冲着这个智慧的数字"⑨"就值得一写。 T1，区间加，单点查。 打个标记就行了。 1 #include <cstdio> 2 #include <cmath> 3 4 const int N = 50010; 5 6 int le[N], re[N], sum[N], tag[N], a[N], fr[N]; 7 8 inli...
【分块】bzoj2453 维护队列
weixin_34409357的博客
12-08 89
http://www.cnblogs.com/autsky-jadek/p/4020296.html 同bzoj2120。 1 #include<cstdio> 2 #include<cmath> 3 #include<cstring> 4 #include<algorithm> 5 using namespace std;...
分块矩阵的逆
DeniuHe的博客
04-10 3486
分块矩阵怎么求逆？ - 知乎四分块矩阵求逆是有通式的（参见分块矩阵求逆公式）下面是一些分块矩阵求逆公式：另可参考Block matrix o…https://www.zhihu.com/question/47760591Matrix inversion identities - 知乎Recently I reviewed some tricks in obtaining the inversion of the matrices. An efficient technique to obtain the i
算法 | 分块查找
热门推荐
yimtcode
10-13 1万+
算法 | 分块查找 1. 简介 分块查找也称为索引顺序表查找。分块查找就是将顺序表（主表）分成若干个子表，然后为每个子表建立一个索引表，利用索引在其中一个子表中查找。 两部分： 索引表：存储顺序表的每个子表的开始索引和最大值。 顺序表：主表所有数据存放的位置。 1.1. 条件 子表内可以是无序的，但是子表之前面的子表中每个元素必须小于后面子表中的每个元素。 1.2. 分块 纯个人的一些理解，欢迎一起沟通交流 1.2.1. 前言 我第一次看分块查找时也十分纠结应该怎么分块每个子表数据应该多长，什么
图像分块与合并
AI数据工厂
06-22 1056
本文提供了一种将大图分块、将小图合并为大图的方法，并给出了实现代码。
HTTP分块传输
HuJunFeng123456的博客
06-18 371
2、需要在头部Trailer说明后面出现的头部列表，如果没有出现头部Trailer则不附带。数据块的长度使用十六进制字符，不包括数据字节块末尾的回车和换行符两个字节。1、每回数据包的前面第一行告诉本次数据块的大小。1、当结束块发送后，后面可以接换行符结尾的头部。指的是把大文件或者大块数据，分成多次来传输。2、考虑单位时间内的吞吐数据量和信道的速度。(一)适合一些不能确定总共字节个数的传输。(二)告知每一块数据的开始和结束的范围。如果有多个数据块，那么是连续发送的。(二)适合灵活多批次的传输。
文件上传之大文件分块上传
Aan___的博客
01-27 537
原则：合久必分，分久必合优势部分：减少了内存占用，可实现，并发处理，利用带宽，提高效率不足之处：增加复杂性，增加额外计算存储大文件上传、多媒体平台音视频上传，需断点续传应用注意事项：合理分块大小，顺序的完整性，异常情况的合理处理。
.net 分块上传例子
04-01
在.NET开发环境中，分块上传是一种处理大文件上传的有效策略，尤其在处理超过单次请求限制的文件时显得尤为重要。这种技术将大文件分割成多个小块，然后逐个上传，确保了上传过程的稳定性和效率。下面我们将深入探讨...
分块算法文档
03-04
分块算法文档 分块算法是数据存储和重复查询的算法，它的核心思想是将大的数据块分割成小的块，并对每个块进行哈希处理，以便快速地検索和查找重复的数据块。下面是对分块算法的详细解释： 1. 数据分块：将大的...
基于图像分块DCT变换的压缩重构算法matlab仿真+仿真操作录像
10-14
《基于图像分块离散余弦变换（DCT）的压缩重构算法MATLAB仿真解析》 在信息技术领域，图像压缩是至关重要的一个环节，它能够有效地减少存储空间和传输带宽。基于图像分块的离散余弦变换（DCT）压缩算法是其中一种...
图像分块代码
11-28
在图像处理领域，分块是一种常见的技术，常用于图像压缩、图像分析以及图像特征提取等任务。本示例中，我们将深入探讨如何使用MATLAB语言实现图像的分块显示，以便更好地理解和操作图像数据。 首先，MATLAB是一种...
函数模板与类模板
程序员_小兵
07-12 1559
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
熟悉python,matlab,C,C++,JAVA等
07-12 381
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 371
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
常见的排序算法，复杂度
最新发布
m0_61544805的博客
07-16 358
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
分块pagerank
12-09
分块Pagerank是一种将大规模的网页图分成多个块进行计算的Pagerank算法。下面是分块Pagerank的步骤： 1.将网页图分成多个块，每个块包含若干个网页节点。 2.对于每个块，计算其内部的Pagerank值。这可以使用常规的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值