【算法·分块】分块入门①-⑥

最新推荐文章于 2022-04-25 21:39:41 发布
最新推荐文章于 2022-04-25 21:39:41 发布
阅读量265 收藏
点赞数
分类专栏： 分块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ronaldo7_ZYB/article/details/88179604
版权

关于分块

关于分块，其主要思想是大局维护，局部朴素；即吧一个序列分成若干个小块，对任意区间进行操作的时候：如果区间内包含完整块，就进行快速的整体修改；若所修改区间内的一部分是某个个块中的一部分，则直接进行暴力修改就行。根据有关数学知识，可以证明分成 n \sqrt n n ​的时间效率最高，一般的时间复杂度则是 O ( n n ) O(n\sqrt n) O(nn ​)

具体内容，我们可以通过六道分块习题进行理解。

分块入门1

给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。

这道题就是分块一个灰常简单的模板了，具体可以这么做：

  • 设修改的区间为 [ l , r ] [l,r] [l,r]，此时在分块中预处理了每一个区间的左端点和右端点，当前枚举为第i个区间。
  • 若区间 i i i在 [ l , r ] [l,r] [l,r]以内，则直接用数组 a d d [ i ] add[i] add[i]进行区间的整体操作，表示第 i i i个区间的所有数的变化量，只需要累加一次。
  • 若区间i的一部分在 [ l , r ] [l,r] [l,r]以内，暴力修改即可。直接在a数组上修改。
  • 对于查询的点x，输出的值为： a [ i ] + a d d [ p o s i ] a[i]+add[pos_i] a[i]+add[posi​], p o s i pos_i posi​表示 i i i所属的块的编号。
    代码如下：

（注意：代码可能与上述讲解的数组含义有所出入）

例如：上面的add是sum，而下面的add是单点变化量，等同于在原数组上做修改。

#include<bits/stdc++.h>
using namespace std;
int n,m;
int a[100000];
int L[100000];
int R[100000];
int add[100000];
int sum[100000];
int num[100000];
void Plus(int l,int r,int c)
{
	for (int i=1;i<=m;++i)
	{
		if (l>R[i] || r<L[i]) continue;
		if (l<=L[i] && r>=R[i]) sum[i]+=c;
		else 
		{
			for (int j=max(L[i],l);j<=min(R[i],r);++j) add[j]+=c;
		}
	}
}
void ask(int x)
{
	printf("%d\n",a[x]+sum[num[x]]+add[x]);
}
int main(void)
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	scanf("%d",&n);
	for (int i=1;i<=n;++i) scanf("%d",a+i);
	m=sqrt(n);
	for (int i=1;i<=m;++i)
	{
		L[i]=sqrt(n)*(i-1)+1;
		R[i]=sqrt(n)*i;
	}	
	if (R[m]<n) 
	{
		m++;
		L[m]=R[m-1]+1;
		R[m]=n;
	}
	for (int i=1;i<=m;++i)
	    for (int j=L[i];j<=R[i];++j)
	        num[j]=i;
	for (int i=1,opt,l,r,c;i<=n;++i)
	{
		scanf("%d %d %d %d",&opt,&l,&r,&c);
		if (opt == 0) Plus(l,r,c);
		if (opt == 1) ask(r);
	}
	return 0;
}

分块入门2

给出一个长为n的数列，以及n个操作，操作涉及区间加法，询问区间内小于某个值x的元素个数。

区间加法的方法同分块1，我们来考虑如何求小于x的元素个数。

对于每一个块，我们可以在一开始分别进行排序，若不进行修改操作就可以直接用二分查找得到答案。

对于区间修改来说，如果是整块的修改则没有关系，因为仍然保证有序性。

如果是两端零零散散的修改，在修改完之后再对这些块分别进行排序。

这个就可以用过二分查找或者lowerbound函数在log的复杂度内解决问题了。

因为分成的块是logn块，时间复杂度是 O ( n n + 2 ∗ n   l o g n ) O(n\sqrt n+2*\sqrt n \ log\sqrt n) O(nn ​+2∗n ​ logn ​)

代码如下：

#include<bits/stdc++.h>
#define find lower_bound
using namespace std;
int n,m;
int a[100000];
int L[100000];
int R[100000];
int pos[100000];
int sum[100000];
vector<int>num[100000];
void reset(int x)
{
	num[x].clear();
	for (int i=L[x];i<=R[x];++i)
	    num[x].push_back(a[i]);
	sort(num[x].begin(),num[x].end());
}
void change(int l,int r,int v)
{
	for (int i=1;i<=m;++i)
	{
		if (l>R[i] || r<L[i]) continue;
		if (l<=L[i] && r>=R[i]) sum[i]+=v;
		else 
		{
			for (int j=max(l,L[i]);j<=min(R[i],r);++j) 
			    a[j]+=v;
			reset(i);
		}
	}
}
void print(int l,int r,int k)
{
	int ans=0;
	for (int i=1;i<=m;++i)
	{
		if (l>R[i] || r<L[i]) continue;
		if (l<=L[i] && r>=R[i]) 
		    ans += find (num[i].begin(), num[i].end(), k*k-sum[i]) - num[i].begin();
		else
			for (int j=max(l,L[i]);j<=min(R[i],r);++j)
			    if (a[j]+sum[pos[j]]<k*k) ans++;
	}
	printf("%d\n",ans);
}
int main(void)
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	scanf("%d",&n);
	for (int i=1;i<=n;++i) 
		scanf("%d",a+i);
	m=sqrt(n);
	for (int i=1;i<=m;++i)
	{
		L[i]=sqrt(n)*(i-1)+1;
		R[i]=sqrt(n)*i;
	}
	if (R[m] < n) 
	{
		m++;
		L[m]=R[m-1]+1;
		R[m]=n;
	}
	for (int i=1;i<=m;++i)
	    for (int j=L[i];j<=R[i];++j)
	        pos[j]=i;
	for (int i=1;i<=m;++i) reset(i);
	for (int i=1,opt,l,r,c;i<=n;++i)
	{
		scanf("%d %d %d %d",&opt,&l,&r,&c);
		if (opt == 0) change(l,r,c);
		if (opt == 1) print(l,r,c);
	}
	return 0;
}

分块入门3

给出一个长为n的数列，以及n个操作，操作涉及区间加法，询问区间内小于某个值x的前驱（比其小的最大元素）。

加法修改和排序和分块2一样，在输出答案的时候需要做一定的修改。

  • 若是整块的区间，则通过lower_bound找到大于等于x的最小值，向后减去1则是小于x的最大值。
  • 不完整暴力即可。

代码如下：

#include<bits/stdc++.h>
#define find lower_bound
using namespace std;
int n,m;
int a[100000];
int L[100000];
int R[100000];
int pos[100000];
int sum[100000];
vector<int>num[100000];
void reset(int x)
{
	num[x].clear();
	for (int i=L[x];i<=R[x];++i)
	    num[x].push_back(a[i]);
	sort(num[x].begin(),num[x].end());
}
void change(int l,int r,int v)
{
	for (int i=1;i<=m;++i)
	{
		if (l>R[i] || r<L[i]) continue;
		if (l<=L[i] && r>=R[i]) sum[i]+=v;
		else 
		{
			for (int j=max(l,L[i]);j<=min(R[i],r);++j) 
			    a[j]+=v;
			reset(i);
		}
	}
}
void print(int l,int r,int k)
{
	int ans=-INT_MAX;
	for (int i=1;i<=m;++i)
	{
		if (l>R[i] || r<L[i]) continue;
		if (l<=L[i] && r>=R[i]) 
		{
			int p=find (num[i].begin() ,num[i].end() ,k-sum[i]) - num[i].begin();
			if (p != 0) ans=max(ans,num[i][p-1]+sum[i]);
		}
		else
		{
			for (int j=max(l,L[i]);j<=min(R[i],r);++j) 
			    if (a[j]+sum[i]<k) ans=max(ans,a[j]+sum[i]);
		}
	}
	printf("%d\n",ans == -INT_MAX ? -1 : ans);
}
int main(void)
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	scanf("%d",&n);
	for (int i=1;i<=n;++i) 
		scanf("%d",a+i);
	m=sqrt(n);
	for (int i=1;i<=m;++i)
	{
		L[i]=sqrt(n)*(i-1)+1;
		R[i]=sqrt(n)*i;
	}
	if (R[m] < n) 
	{
		m++;
		L[m]=R[m-1]+1;
		R[m]=n;
	}
	for (int i=1;i<=m;++i)
	    for (int j=L[i];j<=R[i];++j)
	        pos[j]=i;
	for (int i=1;i<=m;++i) reset(i);
	for (int i=1,opt,l,r,c;i<=n;++i)
	{
		scanf("%d %d %d %d",&opt,&l,&r,&c);
		if (opt == 0) change(l,r,c);
		if (opt == 1) print(l,r,c);
	}
	return 0;
}

分块入门4

给出一个长为n的数列，以及n个操作，操作涉及区间加法，区间求和。
其实做法和分块1还是一样的，在统计答案的时候改一下就好了。

具体做法如下：

  • 遇到整块修改的， a d d i + = v add_i+=v addi​+=v,i表示块的编号，v表示修改量，进行整体修改
  • 遇到非整块修改的， s u m p o s i + = v , a [ i ] + = v sum_{pos_i}+=v,a[i]+=v sumposi​​+=v,a[i]+=v其中sum表示区间和，a表示原始序列的基础上修改的序列。

遇到查询的时候：

  • 如果是整块的，答案是： a d d [ i ] ∗ ( R [ i ] − L [ i ] + 1 ) + s u m [ i ] add[i]*(R[i]-L[i]+1)+sum[i] add[i]∗(R[i]−L[i]+1)+sum[i],表示整体修改所增加的值加上暴力修改所增加的值。
  • 如果是某一块的一部分，暴力喽。

注意，sum数组在未修改之前也需要预处理。

代码如下：

#include<bits/stdc++.h>
#define LL long long
using namespace std;
LL n,m;
LL a[100000];
LL L[100000];
LL R[100000];
LL sum[100000];
LL add[100000];
LL pos[100000];
void change(LL l,LL r,LL c)
{
	for (LL i=1;i<=m;++i)
	{
		if (r<L[i] || l>R[i]) continue;
		if (l<=L[i] && r>=R[i]) add[i]+=c;
		else for (LL j=max(l,L[i]);j<=min(r,R[i]);++j) 
			sum[i]+=c,a[j]+=c;
	}
}
void getans(LL l,LL r,LL P)
{
	LL ans=0;
	for (LL i=1;i<=m;++i)
	{
		if (r<L[i] || l>R[i]) continue;
		if (l<=L[i] && r>=R[i]) ans+=sum[i]+(R[i]-L[i]+1)*add[i],ans%=P;
		else for (LL j=max(l,L[i]);j<=min(r,R[i]);++j)
		    ans+=(add[i]+a[j]),ans%=P;
	}
	printf("%lld\n",ans);
}
int main(void)
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	scanf("%lld",&n);
	for (LL i=1;i<=n;++i) 
		scanf("%lld",a+i);
	m=sqrt(n);
	for (LL i=1;i<=m;++i)
	{
		L[i]=sqrt(n)*(i-1)+1;
		R[i]=sqrt(n)*i;
	}
	if (R[m]<n)
	{
		m++;
		L[m]=R[m-1]+1;
		R[m]=n;
	}
	for (LL i=1;i<=m;++i)
	    for (LL j=L[i];j<=R[i];++j)
	        sum[i]+=a[j],pos[j]=i;
	for (LL i=1,opt,l,r,c;i<=n;++i)
	{
		scanf("%lld %lld %lld %lld",&opt,&l,&r,&c);
		if (opt == 0) change(l,r,c);
		if (opt == 1) getans(l,r,c+1);
	}
	return 0;
}

分块入门5

给出一个长为n的数列，以及n个操作，操作涉及区间开方，区间求和。

我们发现，当一个数进行若干次开方后会不断在0或1中循环，且开方次数很少，我们便可以利用这一性质来解决此题。

因此对于修改的区间：

  • 如果区间是完整的：如果区间全部变成0/1，跳过；如果不是，则暴力修改。
  • 如果是不完整的则暴力修改。

然后暴力用区间和维护即可。

#include<bits/stdc++.h>
using namespace std;
int n,m;
int a[100000];
int L[100000];
int R[100000];
int add[100000];
int pos[100000];
int sum[100000];
int flag[100000];
void sqrtit(int x)
{
	if (flag[x] == 1) return;
	int flg=1;
	sum[x]=0;
	for (int i=L[x];i<=R[x];++i)
	{
		a[i]=sqrt(a[i]);
		sum[x]+=a[i];
		if (a[i]>1) flg=0;
	}
	flag[x]|=flg;
	return;
}
void change(int l,int r)
{
	for (int i=1;i<=m;++i)
	{
		if (l>R[i] || r<L[i]) continue;
		if (l<=L[i] && r>=R[i]) sqrtit(i);
		else for (int j=max(l,L[i]);j<=min(r,R[i]);++j) 
		{
			sum[i]-=a[j];
			a[j]=sqrt(a[j]);
			sum[i]+=a[j];
		}
	}
}
void getans(int l,int r)
{
	int ans=0;
	for (int i=1;i<=m;++i)
	{
		if (l>R[i] || r<L[i]) continue;
		if (l<=L[i] && r>=R[i]) ans+=sum[i];
		else for (int j=max(l,L[i]);j<=min(r,R[i]);++j) ans+=a[j];
	}
	printf("%d\n",ans);
}
int main(void)
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	scanf("%d",&n);
	for (int i=1;i<=n;++i) scanf("%d",a+i);
	m=sqrt(n);
	for (int i=1;i<=m;++i)
	{
		L[i]=(i-1)*sqrt(n)+1;
		R[i]=i*sqrt(n);
	}
	if (R[m]<n)
	{
		m++;
		L[m]=R[m-1]+1;
		R[m]=n;
	}
	for (int i=1;i<=m;++i)
	    for (int j=L[i];j<=R[i];++j)
	    	pos[j]=i,sum[i]+=a[j];
	for (int i=1,l,r,opt,c;i<=n;++i)
	{
		scanf("%d %d %d %d",&opt,&l,&r,&c);
	    if (opt == 0) change(l,r);
		if (opt == 1) getans(l,r);	
	}
	return 0;
}

分块入门6

给出一个长为n的数列，以及n个操作，操作涉及单点插入，单点询问，数据随机生成。

我们把序列分成 n \sqrt n n ​,每次根据查出的位置找到对应的块插入即可。

我们在这里插入使用vector，因为vector支持线性数组的中线插入。

这样的实现复杂度平均好，但是如果某一个块持续插入的话时间复杂度会退化为 O ( n 2 ) O(n^2) O(n2)。

我们在这里引入一个新的思想：重构分块。

即如果某一个块的个数超级超级大了，就把当前的所有块解散，然后重新再分；这样就不会被特殊的数据卡了。

代码如下：

#include<bits/stdc++.h>
using namespace std;
int n,m,now,top;
int a[1000000];
int st[1000000];
vector<int>num[1000000];
void again( )
{
	top=0;
	for (int i=1;i<=m;++i)
	{
	    for (int j=0;j<num[i].size();++j)
	        st[++top]=num[i][j];
	    num[i].clear();
	}
	m=sqrt(top),now=0;
	for (int i=1;i<=m;++i)
	    for (int j=1;j<=m;++j)
	        num[i].push_back(st[++ now]);
	if (now < top) 
	{
		m ++;
		while (now<top) num[m].push_back(st[++ now]);
	}	
}
void insert(int l,int r)
{
	int i=1;
	while (num[i].size()<l)
	{
		l-=num[i].size();
		i ++;
	}
	num[i].insert(num[i].begin()+l-1,r);
	if (num[i].size()>sqrt(n)*20) again();
}
void output(int r)
{
	int i=1;
	while (r>num[i].size())
	{
		r-=num[i].size();
		i ++;
	}
	printf("%d\n",num[i][r-1]);
}
int main(void)
{
	freopen("a.in","r",stdin);
	freopen("a.out","w",stdout);
	scanf("%d",&n);
	for (int i=1;i<=n;++i) scanf("%d",a+i);
	m=sqrt(n),now=0;
	for (int i=1;i<=m;++i)
		for (int j=1;j<=m;++j) 
			num[i].push_back(a[++ now]);
	if (now < n) 
	{
		m ++;
		while (now<n) num[m].push_back(a[++now]);
	}
	for (int i=1,opt,l,r,c;i<=n;++i)
	{
		scanf("%d %d %d %d",&opt,&l,&r,&c);
		if (opt == 0) insert(l,r);
		if (opt == 1) output(r);
	}
	return 0;
}
pigzhouyb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分块入门1~9 （完结撒花）
包子不卖包子
08-23 452
LOJ 终于肝完了分块的九种基础类型，调bug调得是真（超）是（级）开（恶）心。 有脑残的时候，把块的编号当成元素的下表。数组开太小会莫名超时。 建议读者刷LOJ上的分块入门1~9 loj#6277. 数列分块入门 1 区间加法，单点查询 基础的东西 数学老师曰：基本知识不熟悉，难题不会做！ 分块 每个块的大小都是sqrt（n） n=12 N=sqrt（12） 向下取整 3 第一块：1...
数列分块入门1-9 By hzwer
weixin_30632899的博客
08-13 166
声明 持续更新，因为博主也是正在学习分块的知识，我很菜的，菜的抠$jio$ 写在前面 分块是个很暴力的算法，但却比暴力优秀的多，分块算法的时间复杂度一般是根号的，他的主要思想是将一个长度是$n$的数列分为$m$个块,在每个块上维护一些东西，询问的时候才会用到这些维护的东西，就像线段树中的懒标记一样。 Loj #6297. 数列分块入门1 这道题目是分块最基础的题目，仅需要支...
【分块入门1-9】--分块大法好
dimeitong1731的博客
09-20 208
分块一： 给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。 普通分块水过 #include<iostream> #include<cstdio> #include<cmath> #include<cstdlib> using namespace std; int n, a[100100], len,t...
数列分块入门1-9 LibreOJ
weixin_30257433的博客
05-25 125
我也不知道为什么一个大二的ACM选手没学分块。 我怎么记得大一的时候，学长教给我的分块就只有 block 和 num 两个变量来着...好吧，应该是我没认真学。正好前两天朋友给学弟开课，乘机去蹭了一节课。然后...我还是不会哇，菜的一逼塌糊涂。 还是 卿学姐 好哇，多听几遍，睡得贼香。 分块原理 分块嘛，其实就是优雅的暴力，和莫队（不会）有点异曲同工的赶脚。通过将数组分成小块以降低复杂度。 通常情...
loj 数列分块入门 1 ~ 9 做题笔记
TMJYH09's csdn blog
04-25 936
前言 做了 hzwer 的分块系列（ %%% hzwer 学长 loj6277 数列分块入门 1 给定数列，区间修改，单点查询。 区间修改可以打永久标记。没什么好说的，毕竟是 1。 #include <bits/stdc++.h> #define int long long using namespace std; inline int read(){ int x=0,f=0;char ch=getchar(); while(!isdigit(ch))f^=!(ch^45)
算法-数列分块入门 7（LibreOj-6283）.rar
09-16
《算法-数列分块入门 7（LibreOj-6283）》是针对计算机科学领域中的一种常用算法技巧——数列分块进行深入解析的教程。数列分块是一种优化线性结构查询的技术，常用于解决大规模数据处理问题，尤其是在动态维护和...
算法-数列分块入门 8（LibreOj-6284）.rar
09-16
《算法-数列分块入门 8（LibreOj-6284）》是针对编程算法学习者的一份重要资源，主要讲解了数列分块这一算法思想及其在解决实际问题中的应用。数列分块作为一种优化数据结构和算法效率的方法，在处理大规模数据时尤...
算法-数列分块入门 6（LibreOj-6282）.rar
09-16
《算法-数列分块入门 6（LibreOj-6282）》是针对计算机算法领域中一种常用的技术——数列分块技术进行详细介绍的资源。数列分块是解决大规模数据处理和在线算法问题时的一种有效策略，尤其在面对动态查询和更新的...
算法-数列分块入门 2（LibreOj-6278）.rar
09-16
这个压缩包文件“算法-数列分块入门 2（LibreOj-6278）.rar”包含了一份关于数列分块的教程，可能是为了帮助学习者理解并解决LibreOj上的第6278题。虽然没有具体的标签信息，但我们可以从标题和描述中推测，这份资料...
算法-数列分块入门 9（LibreOj-6285）.rar
09-16
《算法-数列分块入门 9（LibreOj-6285）》是针对计算机科学领域中的一种常用优化技巧——数列分块技术的详细讲解。数列分块是解决大规模数据处理问题时的一种高效策略，尤其在算法竞赛如LibreOj等在线判题平台上，...
分块入门1~9题解
hzk_cpp的博客
05-06 308
分块入门1：LOJ6277. 题目大意：给定一个长度为nnn的序列以及nnn个操作，操作设计区间加法，单点查值. 1≤n≤5∗1041\leq n\leq 5*10^41≤n≤5∗104. 分块，每个块维护一个tagtagtag表示这个块被整体加了多少. 代码如下： #include<bits/stdc++.h> using namespace std; #define Abig...
数列分块入门1-9（未完）
坚持迟早会有收获的！！！
05-12 351
链接：数列分块入门数列分块入门1：题意：区间更新，单点查询代码：#include&lt;bits/stdc++.h&gt; using namespace std; typedef long long ll; const int mx = 50010; int num, block; int l[mx], r[mx]; int belong[mx]; int a[mx]; int add[mx]...
「分块」数列分块入门1 – 9
Fighting_Peter的博客
07-05 273
放暑假了，回归！！！ 自己不会写暴力，而且好久没写代码了，于是学学分块的优雅暴力~ 「分块入门-LibreOJ」 「分块」数列分块入门1 – 9 by hzwer 数列简单分块问题实际上有三项东西要我们思考： 对于每次区间操作： 不完整的块 的O(n)O(\sqrt n)O(n​)个元素怎么处理？ O(n)O(\sqrt n)O(n​)个 整块 怎么处理？ 要预处理什么信息（复杂度不能超过后面的操作一般O(NN)O(N\sqrt N)O(NN​)预处理） 下面假设块的大小为MMM #6277
【分块入门】LOJ 数列分块入门 1 - 9 (学习更新……)
L_X_
01-16 2057
dl题解_「分块」数列分块入门1 – 9 by hzwer LOJ #6277. 数列分块入门 1 题意：给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。 时间限制：100ms 分块 我们将整个数列划分为很多块，暂且分为n / m块，用block[ i ]记录第 i 个数据arr[ i ]对应的块的个数。O(n)【数据读入时就可以操作完成，block[ i ] = (i ...
数列分块入门4-6题解
qq_52088973的博客
08-23 332
lll
LibreOj6280 数列分块入门 4 区间加法+区间和
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
05-25 203
数列分块入门 4 链接：LibreOj6280 题目描述 给出一个长为n的数列，以及n个操作，操作涉及区间加法，区间求和。 输入格式 第一行输入一个数字n。 第二行输入n个数字，第i个数字为 a[i]，以空格隔开。 接下来输入n行询问，每行输入四个数字op、l、r、c，以空格隔开。 若 op==0，将[l,r]之间的数字都加上c 若 op==1，表示询问[l,r]所有数字的和%(c+1) 输出格式...
线性结构 —— 分块算法 —— 分块九讲
Alex_McAvoy的博客
08-02 1271
模型1：区间加法，单点询问 问题：给出一个长为 n 的数列，以及 n 个操作，操作涉及区间加法，单点查值。 对每个块设置一个加法标记，记录这个块中元素一共加了多少，每次操作对整块直接 O(1) 标记，而不完整块元素较少，暴力修改元素的值即可，每次询问时返回元素的值加上其所在块的加法标记。 模型2：区间加法，询问区间内小于某个值 x 的元素个数 问题：给出一个长为 n 的数列，以及 n 个操...
分块——例题2
蒟蒻柴犬首相的博客
03-12 250
不懂分块的可以参见博客： 分块传送门 例题2 题目描述 给出一个长为n的数列，以及n个操作，操作涉及区间加法，询问区间内小于某个值x的元素个数。 输入格式 第一行输入一个数字 n 第二行输入 n 个数字，第 i 个数字为a[i]，以空格隔开 接下来输入 n 行询问，每行输入四个数字 opt, l，r，c, 以空格隔开 若 opt = 0，表示将 [l,r] 的之间的数都加 c...
数列分块2
ehdhg13455的博客
09-25 197
题意：给出一个长为n的数列，以及n个操作，操作涉及区间加法，询问区间内小于某个值x的元素个数。 有了上一题的经验，我们可以发现，数列简单分块问题实际上有三项东西要我们思考： 对于每次区间操作： 1.不完整的块的O(√n)个元素怎么处理？ 2.O(√n)个整块怎么处理？ 3.要预处理什么信息（复杂度不能超过后面的操作）？ 我们先来思考只有询问操作的情况，不完整的块枚举统计即...
LOJ-6279-数列分块入门3(分块, 二分)
最新发布
05-24
(分块) $O(n\sqrt n)$ 我们可以预处理出每一个块的信息，每个块又分为若干小块，每个小块中的数都小于等于块中的最大值，可以用二分查找确定小块中满足条件的数的个数，然后用根号分治处理。 时间复杂度 每次查询...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值