数据结构——分块

最新推荐文章于 2023-05-10 13:22:20 发布
最新推荐文章于 2023-05-10 13:22:20 发布
阅读量973 收藏 1
点赞数 1
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hungry1234/article/details/119741513
版权

1.分块思想：将一个数组分成若干块，每次修改或查询时候对整块一起修改，多余的暴力修改(分块是对暴力的优化）

分块初始化：

void init(){
		int len=sqrt(n);
		for(int i=1;i<=n;i++){
			id[i]=(i-1)/len+1;//每个数处于哪一段
			s[i]=w[i];
		}
		for(int i=1;i<=ceil((double)n/len);i++){
			int l=lower_bound(id+1,id+n+1,i)-id;
			int r=upper_bound(id+1,id+n+1,i)-id-1;
			le[i]=l;
			ri[i]=r;//每段的左右边界
			sort(w+l,w+r+1);
		//	cout<<i<<" "<<l<<" "<<r<<endl;
		}
	}

2.操作

1.区间修改

1）只有加法

思路：不成整块的暴力修改，整块的标记修改(感觉和线段树lazytag很像

void insert(int l,int r,int x){
	int len=sqrt(n);
		for(int i=l;i<=ri[l];i++){
			w[i]+=x;
		}
		for(int i=id[l]+1;i<id[r];i++){
			add[i]+=x;
		}
		if(id[l]==id[r]) return ;
		for(int i=le[id[r]];i<=r;i++){
			w[i]+=x;
		}
	}

只有乘法的相似

2）加乘结合

思路：每次更新时候先把不成整段的标记使用后清零再暴力更新，其他的做加法时在加法标记上更新，乘法时候加法标记和乘法标记都要更新

struct fk{//结构体封装
	int w[100010],id[100010],add[350],mul[350],n,len,le[350],ri[350],mod;
	void init(){
		mod=1e4+7;
		for(int i=1;i<=ceil((double)n/len);i++) mul[i]=1;
		for(int i=1;i<=n;i++) id[i]=(i-1)/len+1;
		for(int i=1;i<=n/len;i++){
			le[i]=lower_bound(id+1,id+n+1,i)-id;
			ri[i]=upper_bound(id+1,id+n+1,i)-id-1;
		}
		if(n%len){
			le[n/len+1]=lower_bound(id+1,id+n+1,n/len+1)-id;
			ri[n/len+1]=n;
		}
	}
	void to_add(int l,int r,int x){
		if(id[l]==id[r]){
			for(int i=le[id[l]];i<=ri[id[l]];i++) w[i]=(w[i]*mul[id[i]]+add[id[i]])%mod;
			for(int i=l;i<=r;i++){
				w[i]=(w[i]+x)%mod;
			}
			add[id[l]]=0; 
			mul[id[l]]=1;
			return ;
		}
		for(int i=le[id[l]];i<=ri[id[l]];i++) w[i]=(w[i]*mul[id[i]]+add[id[i]])%mod;
		for(int i=le[id[r]];i<=ri[id[r]];i++) w[i]=(w[i]*mul[id[i]]+add[id[i]])%mod;
		add[id[l]]=add[id[r]]=0;
		mul[id[l]]=mul[id[r]]=1;
		for(int i=l;i<=ri[id[l]];i++) w[i]=(w[i]+x)%mod;
		for(int i=id[l]+1;i<id[r];i++) add[i]=(add[i]+x)%mod;
		for(int i=le[id[r]];i<=r;i++) w[i]=(w[i]+x)%mod;
	}
	void to_mul(int l,int r,int x){
		if(id[l]==id[r]){
			for(int i=le[id[l]];i<=ri[id[l]];i++) w[i]=(w[i]*mul[id[i]]+add[id[i]])%mod;
			for(int i=l;i<=r;i++){
				w[i]=w[i]*x%mod;
			}
			add[id[l]]=0; 
			mul[id[l]]=1;
			return ;
		}
		for(int i=le[id[l]];i<=ri[id[l]];i++) w[i]=(w[i]*mul[id[i]]+add[id[i]])%mod; 
		for(int i=le[id[r]];i<=ri[id[r]];i++) w[i]=(w[i]*mul[id[i]]+add[id[i]])%mod;  
		add[id[l]]=add[id[r]]=0;
		mul[id[l]]=mul[id[r]]=1;
		for(int i=l;i<=ri[id[l]];i++) w[i]=w[i]*x%mod;
		for(int i=id[l]+1;i<id[r];i++){
			add[i]=add[i]*x%mod;
			mul[i]=mul[i]*x%mod;
		} 
		for(int i=le[id[r]];i<=r;i++) w[i]=w[i]*x%mod;
	}
	int get_ans(int i){//加法标记已经在每次操作时候都乘上乘法标记了，所以先加后乘
		int ans=w[i];
		ans=ans*mul[id[i]]%mod;
		ans=(ans+add[id[i]])%mod;	
		return ans;
	}
};

 3）开根号

每个数在有限次开根号后向下取整都会变成0/1，分块记录一块是否都是0/1，否则暴力修改（int范围内每个数最多更新log(2)31=5次，时间复杂度正确

	void do_sqrt(int l,int r){
		if(id[l]==id[r]){
			for(int i=l;i<=r;i++){
				sum[id[l]]-=w[i];
				w[i]=sqrt(w[i]);
				sum[id[l]]+=w[i];
			}
			bool o=true;
			for(int i=le[id[l]];i<=ri[id[l]];i++){
				if(w[i]!=0&&w[i]!=1){
					o=false;
					break;
				}
			}
			ok[id[l]]=o;
		}else{
			if(!ok[id[l]]){
				for(int i=l;i<=ri[id[l]];i++){
					sum[id[l]]-=w[i];
					w[i]=sqrt(w[i]);
					sum[id[l]]+=w[i];
				}
				bool o=true;
				for(int i=le[id[l]];i<=ri[id[l]];i++){
					if(w[i]>1){
						o=false;
						break;
					}
				}
				ok[id[l]]=o;
			}
			for(int i=id[l]+1;i<id[r];i++){
			//	if(ok[i]) cout<<"*";
				if(!ok[i]){
					bool o=true;
					for(int j=le[i];j<=ri[i];j++){
						sum[i]-=w[j];
						w[j]=sqrt(w[j]);
						sum[i]+=w[j];
			//			cout<<j<<" "<<w[j]<<endl;
						if(w[j]>1) o=false;
					}
					ok[i]=o;
				}
			}
			if(!ok[id[r]]){
				for(int i=le[id[r]];i<=r;i++){
					sum[id[r]]-=w[i];
					w[i]=sqrt(w[i]);
					sum[id[r]]+=w[i];
				}
				bool o=true;
				for(int i=le[id[r]];i<=ri[id[r]];i++){
					if(w[i]!=0&&w[i]!=1){
						o=false;
						break;
					}
				}
				ok[id[r]]=o;
			}
		}
	}

2.区间查询

1）小于某数的数量

记录一个原数列和一个每块都从小到大排好序的数列，不是整段的暴力查找，是整段的二分查找

	void ad(int l,int r,long long x){
		if(id[l]==id[r]){
			for(int i=l;i<=r;i++){
				s[i]+=x;
			}
			for(int i=le[id[l]];i<=ri[id[l]];i++){
				w[i]=s[i];
			}
			sort(w+le[id[l]],w+ri[id[l]]+1);
			return ;
		}
		
		for(int i=l;i<=ri[id[l]];i++){
			s[i]+=x;
		}
		for(int i=le[id[l]];i<=ri[id[l]];i++) w[i]=s[i];
		sort(w+le[id[l]],w+ri[id[l]]+1);
		
		for(int i=id[l]+1;i<id[r];i++){
			add[i]+=x;
		}
		
		for(int i=le[id[r]];i<=r;i++){
			s[i]+=x;
		}
		for(int i=le[id[r]];i<=ri[id[r]];i++) w[i]=s[i];
		sort(w+le[id[r]],w+ri[id[r]]+1);
	}//更新操作时候注意数的对应，应在保存原数列的数组上更新然后再转移到排序的数列
	int query(int l,int r,long long x){
		int ans=0;
		if(id[l]==id[r]){
			for(int i=l;i<=r;i++){
				if(s[i]+add[id[l]]<x) ans++;
			}
			return ans;
		}
		
		for(int i=l;i<=ri[id[l]];i++){
			if(s[i]+add[id[l]]<x) ans++;
		}
		
		for(int i=id[l]+1;i<id[r];i++){
			ans=ans+lower_bound(w+le[i],w+ri[i]+1,x-add[i])-(w+le[i]);//二分查找
		}
		
		for(int i=le[id[r]];i<=r;i++){
			if(s[i]+add[id[r]]<x) ans++;
		}
		
		return ans;
	}

2）.查询众数

众数一定来源于未构成整块的数的值和整块中出现的众数，要预处理出整块l~r的众数

struct fk{
	int n,len,gs,w[40010],ans[36][36][40010],cs[36][40010],id[40010],le[36],ri[36];
	int q[40010];
	node qr[36][36];
	void init(){
		for(int i=1;i<=n;i++){
			id[i]=(i-1)/len+1;
			if(i%len==1){
				for(int j=1;j<=gs;j++){
					cs[id[i]][j]=cs[id[i]-1][j];
				} 
			}
			cs[id[i]][w[i]]++;
		}
		for(int l=1;l<=ceil((double)n/len);l++){
			for(int r=l;r<=ceil((double)n/len);r++){
				for(int i=1;i<=gs;i++){
					ans[l][r][i]=cs[r][i]-cs[l-1][i];
					if(ans[l][r][i]>qr[l][r].gs||(ans[l][r][i]==qr[l][r].gs&&q[i]<q[qr[l][r].w])){
						qr[l][r].w=i;
						qr[l][r].gs=ans[l][r][i];
					}
				}
			}
		}//预处理块l~块r中出现的众数
		for(int i=1;i<=n/len;i++){
			le[i]=lower_bound(id+1,id+n+1,i)-id;
			ri[i]=upper_bound(id+1,id+n+1,i)-id-1;
		}
		if(n%len){
			le[n/len+1]=lower_bound(id+1,id+n+1,n/len+1)-id;
			ri[n/len+1]=n;
		}
	}
	int query(int l,int r){
		int ans_gs=0,ans_w=0;
		if(id[l]==id[r]){
			for(int i=l;i<=r;i++){
//				cout<<i<<" "<<w[i]<<endl;
				ans[0][0][w[i]]++;
				if(ans[0][0][w[i]]>ans_gs||(ans_gs==ans[0][0][w[i]]&&q[w[i]]<q[ans_w])){
					ans_gs=ans[0][0][w[i]];
					ans_w=w[i];
				}	
			}
			for(int i=l;i<=r;i++) ans[0][0][w[i]]--;
			return ans_w;
		}
		ans_gs=qr[id[l]+1][id[r]-1].gs;
		ans_w=qr[id[l]+1][id[r]-1].w;
		for(int i=l;i<=ri[id[l]];i++){
			ans[id[l]+1][id[r]-1][w[i]]++;
			if(ans[id[l]+1][id[r]-1][w[i]]>ans_gs||(ans[id[l]+1][id[r]-1][w[i]]==ans_gs&&q[w[i]]<q[ans_w])){
				ans_gs=ans[id[l]+1][id[r]-1][w[i]];
				ans_w=w[i];
			}
		}
		for(int i=le[id[r]];i<=r;i++){
			ans[id[l]+1][id[r]-1][w[i]]++;
			if(ans[id[l]+1][id[r]-1][w[i]]>ans_gs||(ans[id[l]+1][id[r]-1][w[i]]==ans_gs&&q[w[i]]<q[ans_w])){
				ans_gs=ans[id[l]+1][id[r]-1][w[i]];
				ans_w=w[i];
			}
		}
		for(int i=l;i<=ri[id[l]];i++) ans[id[l]+1][id[r]-1][w[i]]--;
		for(int i=le[id[r]];i<=r;i++) ans[id[l]+1][id[r]-1][w[i]]--;
		return ans_w;
	}
};

 3.插入

正常操作，对于每个过大的块分成两半

	void rebuild(int id){//将这一块后所以块向后推，这一块分成两半
		gs++;
		int las[1010],lassz;
		for(int i=1;i<=size[id+1];i++){
			las[i]=w[id+1][i];
		}
		lassz=size[id+1];
		for(int i=id+2;i<=gs;i++){
			int s[1010],sz;
			for(int j=1;j<=size[i];j++){
				s[j]=w[i][j];
			}
			sz=size[i];
			for(int j=1;j<=lassz;j++){
				w[i][j]=las[j];
			}
			size[i]=lassz;
			for(int j=1;j<=sz;j++){
				las[j]=s[j];
			}
			lassz=sz;
		}
		int k=size[id]/2;
		for(int i=k+1;i<=size[id];i++){
			las[i-k]=w[id][i];
		}
		size[id+1]=size[id]-k;
		for(int i=1;i<=size[id+1];i++) w[id+1][i]=las[i];
		size[id]=k; 
	}
	void insert(int k,int x){
		int p=1;
		while(k-size[p]>0){
			k-=size[p];
			p++;
		} 
		for(int i=k;i<=size[p]+1;i++){
			int o=w[p][i];
			w[p][i]=x;
			x=o;
		}
		size[p]++;
		if(size[p]>800){//块过大，重构
			rebuild(p);
		}
	}

 

hungry1234
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
数据结构——查找
07-17
数据结构中的查找是数据操作的重要组成部分，主要涉及在数据集合中寻找特定元素的过程。查找算法的性能直接影响到程序的效率，特别是在大规模数据处理时。本文将深入探讨几种常见的查找技术，包括顺序查找、二分查找...
块状数据结构——分块
nuoyanli的博客
01-15 2078
介绍和认识： 分块算法实质上是一种是通过分成多块后在每块上打标记以实现快速区间修改，区间查询的一种算法。其均摊时间复杂度为O(n)O(\sqrt n)O(n​)。 分块算法相较于各种高级数据结构，具有简便易写，方便调试等多种优点。在同等数据规模下，如 1e51e51e5 ，其时间效率并不会低太多，在很多时反而是一种更好的选择。 分块算法; 为了使得其有着最稳定的时间复杂度，我们经常将一个长度为nn...
【数据结构】分块
weixin_54994444的博客
05-09 463
分块本质上就是一个优化的暴力算法，它的思路通俗易懂，虽然时间复杂度不及那些高级数据结构，但仔细想想，线段树和树状数组处理每一步的时的效率为$\log n$，分块的效率则为$\sqrt n$，显然$\sqrt n$比$\log n$要处理的次数多上不少，但也是属于能过的状态，况且线段树因为巨大的常数有时还不如分块。
数据分块算法整理
qq_41231609的博客
07-27 2758
固定分块检测技术 基于FSP算法的块检测技术 完全文件检测不能用于文件内部的重复数据查找， 因此有研究者提出了更细粒度–块级别的重复数据检测。基于固定尺寸划分算法的相同数据块检测技术是使用固定大小的分块策略在存储系统中识别相同数据的方法 1）提供一个已经预先定义好的块的大小（该值独立于所存取的数据容），所有文件均按照这个固定的块大小进行划分。 2）每个划分好的数据块均通过哈希算法得到一个指纹值。 3）将该值与已存储的指纹值进行比对，如果检测到相同的值，则删除其代表的数据块，否则存储新的数据块。 可变分块检测
数据结构：分块学习笔记
m0_72410588的博客
05-10 173
分块是一种将一个序列划分为若干个块，并对每个块记录一些辅助信息的数据结构。具体而言，可以将一个长度为nnn的序列分成n\sqrt{n}n​个块，每个块包含n\sqrt{n}n​个元素。在进行操作时，首先找到所在块，然后暴力计算块内元素或者利用辅助信息计算。分块是一种常见的数据结构，可以用于解决各种问题。它可以在OnO(\sqrt n)On​的时间内完成区间询问。分块数据结构常见的优化技巧包括预处理块内信息、使用分块信息缓存、懒惰标记、使用优化常数的数据结构等。
数据结构英文课件：Chap9 Searching.ppt
06-12
在数据结构的学习中，搜索是核心操作之一，用于在数据集合中查找特定的元素或信息。本章——Chapter 9 "Searching"——主要探讨了不同类型的搜索算法及其效率。以下是关于几种搜索方法的详细说明： 1. **Searching*...
数据结构课程设计—————文章的编辑
05-02
数据结构课程设计主要关注的是如何实现一个文章编辑器，该编辑器具备文字处理的基本功能，如增删改插。在本文中，我们将深入探讨这个编辑器的各个关键组成部分及其背后的逻辑。 首先，编辑器需要一个友好的用户界面...
数据结构计划书
01-07
在这个数据结构计划书中，主要讨论的是一个具体的实践项目——分块查找算法，它结合了折半查找和顺序查找两种方法。 首先，折半查找（Binary Search）是一种在有序数组中查找特定元素的搜索算法。它的基本思想是...
数据库技术知识数据结构的算法.doc
12-21
数据库技术中的数据结构和算法是理解数据库工作原理的关键部分，它们直接影响到数据的存储、查询效率和整体系统性能。以下是对这些知识点的详细说明： 1. **数据元素和数据项**：数据的基本单位是数据元素，它可能...
数据结构——分块算法
weixin_43115940的博客
01-08 601
可能涉及的名词解释 ①区间：数列中连续的一段元素 ②区间操作：将某个区间[a,b]的所有元素进行某种改动的操作 ③块：我们将数列划分成若干个不想交的区间，每个区间成为一个块 ④整块：一个区间操作时，完整包含于区间的块 ⑤：不完整的块 什么是分块？ 分块其实就是将一个连续的序列分成若干段长度相等的片段，这些片段我们称之为块.。 一般用于解决区间修改与询问，它可以解决以下一些问题： 1.给出一个长为n...
在Python中使用多进程快速处理数据
Bryan__的专栏
12-12 1万+
数据分片：可以将数据分片处理的任务适合用多进程代码处理，核心思路是将data分片，对每一片数据处理返回结果(可能是无序的)，然后合并。应用场景：多进程爬虫，类mapreduce任务。缺点是子进程会拷贝父进程所有状态，内存浪费严重。import math from multiprocessing import Pool def run(data, index, size): # data 传入数...
使用LASlib(LASTool)库对LAS文件进行分割
Jared_Chen的博客
04-22 3048
在实际的项目，有很多时候，我们会遇到一个巨大的las文件，比如7,8个G的大小。这时候，我们需要对这个大的las文件进行分块保存为多个小的las文件。可是按照点的个数进行保存，也可以按照内存的大小保存。实际上也就是对点云的读写过程。具体的代码如下所示： void lasFileDivision() { LASreadOpener lasreadopener; LASwrite...
数据结构:分块总结
weixin_44221747的博客
06-28 210
分块 分块的基本思想是通过适当的划分，预处理一部分信息并保存下来，用空间换取时间，达到时空平衡。事实上，分块的算法更接近“朴素”，效率往往比不上树状数组和线段树，但是它更加通用且容易实现。 下面从题目入手 这道题的题意非常熟悉，毕竟我们之前拿线段树和树状数组都做过，对于分块算法来说，这道题处理起来要比另两种简单许多。 大致思路如下 首先我们先把这个序列分成t=sqrt(n)t=sqrt(n)t=sqrt(n)个块,然后每一个块的首位分别是w[i]*t-t和w[i]*t. 对于每一个加操作,我们将其分成两步
数据结构之分块
DancingZ的博客
07-11 1167
时间复杂度：n√n Q:和线段树等较复杂数据结构相比，它有什么优势？ A:首先，看到时间复杂度会让人联想到哪个算法？ Q:莫队。 A:是的，莫队！莫队号称能解决一切区间问题，然而它是离线的；但是我们的分块却是在线处理！！！ 1）数据结构能接受的数据范围分块基本上能搞 2）分块代码短，容易调试 这两个优点不是秒掉主席树，树套树，splay…… 一、基础分块 hzwer入门8题：传送...
数据结构进阶之分块
m0_55341679的博客
10-10 145
分块
文件数据块分块算法解析
chenglinhust的专栏
04-09 5857
文件数据块分块算法解析 1. 简介        存储系统的重复数据删除过程一般是这样的：首先将数据文件分割成一组数据块，为每个数据块计算指纹，然后以指纹为关键字进行Hash查找，匹配则表示该数据块为重复数据块，仅存储数据块索引号，否则则表示该数据块是一个新的唯一块，对数据块进行存储并创建相关元信息。这样，一个物理文件在存储系统就对应一个逻辑表示，由一组FP组成的元数据。当进行读取
数据处理：1 用pandas处理大型csv文件 2 使用Pandas分块处理大文件 3 分块读取
热门推荐
wld的博客
08-05 5万+
在训练机器学习模型的过程中，源数据常常不符合我们的要求。大量繁杂的数据，需要按照我们的需求进行过滤。拿到我们想要的数据格式，并建立能够反映数据间逻辑结构的数据表达形式。  最近就拿到一个小任务，需要处理70多万条数据。 我们在处理CSV文件时，经常使用的大熊猫，可以帮助处理较大的CSV文件。 大熊猫中处理CSV文件的函数主要为read_csv() 状语从句：to_csv()这两个，其中read...
Laravel 大数据量分块处理
彳亍
02-24 9889
chunk() 的用法 有时，我们可能会一次性查出很大的结果集（上万条记录），这样就很可能导致内存溢出。 Laravel 框架的 chunk() 方法，可以将数据分块，每次只查询指定数量的数据块，交给回调函数处理。从而在处理大量数据集合时，能够有效减少内存消耗。 User::where('status', 0)-&gt;chunk(100, function ($users) { ...
王道408数据结构应用题
最新发布
08-17
王道408数据结构的应用题是指在408考试中出现的与数据结构相关的实际应用题目。在这些题目中，可能会涉及到顺序查找、折半查找、分块查找等算法。王道书中给出了这些算法的代码实现，但对于考408的同学来说，掌握这些代码并不是必须的，因为408的代码题没有像自主命题那样深入和难度那么大。对于线性表的顺序表示、串以及栈和队列的实现，也不需要手写实现，可以使用标准库来解决问题。只有在题目要求你手动实现栈和队列等数据结构时，才需要进行手写实现。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [408王道数据结构强化——应用题](https://blog.csdn.net/JiangNan_1002/article/details/125828454)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [【23考研】计算机408数据结构代码题强化阶段划重点（王道书）](https://blog.csdn.net/qq_50710984/article/details/125583743)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值