分块

最新推荐文章于 2023-07-28 23:17:14 发布
最新推荐文章于 2023-07-28 23:17:14 发布
阅读量413 收藏 3
点赞数 2
分类专栏： 分块 文章标签： 分块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44574520/article/details/100637147
版权

数列分块入门 1

  • 给定一个长度为 n n n的序列，有 n n n个操作，区间加法和单点询问

  • 将序列分成 s q r t ( n ) sqrt(n) sqrt(n)个块

  • 对于一段区间修改，分两种情况讨论：

  • 如果修改区间在一个块中，则暴力修改 a [ i ] a[i] a[i]的值

  • 如果修改区间不在一个块中：
    对于最左边和最右边的块，暴力修改
    中间的整块维护一个块的 l a z y lazy lazy值

  • 时间复杂度 O ( ( n / m ) + m ) O((n/m)+m) O((n/m)+m)，根据均值不等式， m = s q r t ( n ) m=sqrt(n) m=sqrt(n)时最优

#include <bits/stdc++.h>
using namespace std;
#define maxn 50010

int n,a[maxn],L[maxn],R[maxn],t,pos[maxn],la[maxn];

inline int read_() {
	int x_=0,f_=1;char c_=getchar();
	while(c_<'0'||c_>'9') {if(c_=='-') f_=-1;c_=getchar();}
	while(c_>='0'&&c_<='9') {x_=(x_<<1)+(x_<<3)+c_-'0';c_=getchar();}
	return x_*f_;
}

inline void update_(int l,int r,int w) {
	int LL=pos[l],RR=pos[r];
	if(LL==RR) for(int i=l;i<=r;++i) a[i]+=w;
	else {
		for(int i=l;i<=R[LL];++i) a[i]+=w;
		for(int i=L[RR];i<=r;++i) a[i]+=w;
		for(int i=LL+1;i<=RR-1;++i) la[i]+=w;
	}
}

void readda_() {
	n=read_();
	for(int i=1;i<=n;++i) a[i]=read_();
	t=sqrt(n);//块的大小亦块数,t*t=n 
	for(int i=1;i<=t;++i) {
		L[i]=(i-1)*t+1;
		R[i]=i*t;
	}
	if(R[t]<n) {++t;L[t]=R[t-1]+1;R[t]=n;} 
	for(int i=1;i<=t;++i) {
		for(int j=L[i];j<=R[i];++j) {
			pos[j]=i;//每个点属于哪个块 
		}
	}
	for(int i=1;i<=n;++i) {
		int pd=read_(),l=read_(),r=read_(),c=read_();
		if(!pd) update_(l,r,c);
		else printf("%d\n",a[r]+la[pos[r]]);
	}
}

int main() {
	freopen("a.txt","r",stdin);
	readda_();
	return 0;
}

数列分块入门 2

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

  • 要快速查询一个区间小于 x x x的数有多少，在区间有序的情况下我们可以使用二分 l o w e r lower lower_ b o u n d bound bound

  • 维护出块之后，给每个块内排序，使块内元素有序

  • 考虑修改：
    如果一整个块都加上一个数，不影响块内元素的相对大小
    如果修改一个块内的部分的数，则有可能会影响相对大小，在修改完之后，重新排序

  • 考虑询问：
    如果询问一整个块的话使用二分
    否则暴力询问

#include <bits/stdc++.h>
using namespace std;
#define maxn 50010
#define maxt 225

int n,a[maxn],L[maxt],R[maxt],pos[maxn],t,la[maxt];
vector <int >e[maxt];

inline int read_() {
	int x_=0,f_=1;char c_=getchar();
	while(c_<'0'||c_>'9') {if(c_=='-') f_=-1;c_=getchar();}
	while(c_>='0'&&c_<='9') {x_=(x_<<1)+(x_<<3)+c_-'0';c_=getchar();}
	return x_*f_;
}

inline void resert_(int x) {
	e[x].clear();
	for(int i=L[x];i<=R[x];++i) e[x].push_back(a[i]);
	sort(e[x].begin(),e[x].end());
}

inline void update_(int l,int r,int w) {
	int LL=pos[l],RR=pos[r];
	if(LL==RR) {
		for(int i=l;i<=r;++i) a[i]+=w;
		resert_(LL); 
	}
	else {
		for(int i=l;i<=R[LL];++i) a[i]+=w;
		resert_(LL);
		for(int i=L[RR];i<=r;++i) a[i]+=w;
		resert_(RR);
		for(int i=LL+1;i<=RR-1;++i) la[i]+=w;
	}
}

inline int query_(int l,int r,int w) {
	int LL=pos[l],RR=pos[r];
	int ans=0;
	if(LL==RR) {
		for(int i=l;i<=r;++i) {
			if(a[i]+la[pos[i]]<w) ++ans;
		}
	}
	else {
		for(int i=l;i<=R[LL];++i) {
			if(a[i]+la[pos[i]]<w) ++ans;
		} 
		for(int i=L[RR];i<=r;++i) {
			if(a[i]+la[pos[i]]<w) ++ans;
		}
		for(int i=LL+1;i<=RR-1;++i) {
			ans+=lower_bound(e[i].begin(),e[i].end(),w-la[i])-e[i].begin();
		}
	}
	return ans;
}

void readda_() {
	n=read_();
	for(int i=1;i<=n;++i) a[i]=read_();
	t=sqrt(n);
	for(int i=1;i<=t;++i) {
		L[i]=(i-1)*t+1;
		R[i]=i*t;
	}
	if(R[t]<n) {++t;L[t]=R[t-1]+1;R[t]=n;}
	for(int i=1;i<=t;++i) {
		for(int j=L[i];j<=R[i];++j) {
			pos[j]=i;
			e[i].push_back(a[j]);
		}
		sort(e[i].begin(),e[i].end());
	}
	for(int i=1;i<=n;++i) {
		int pd=read_(),l=read_(),r=read_(),c=read_();
		if(!pd) update_(l,r,c);
		else printf("%d\n",query_(l,r,c*c));
	}
}

int main() {
	freopen("a.txt","r",stdin);
	readda_();
	return 0;
}

数列分块入门 3

  • 给出一个长为 n n n的数列，以及 n n n个操作，操作涉及区间加法，询问区间内小于某个值 x x x的前驱（比其小的最大元素）。
  • 和上一题差不多，使块内的元素单调，可以使用二分查询 x x x的位置， x x x的前驱就是其前面那个
  • 我们开个 v i s [ i ] vis[i] vis[i]表示 i i i号块是否被暴力修改，在查询时再去维护其单调性，不用修改了就去维护，有可能询问区间不涉及暴力修改区间
#include <bits/stdc++.h>
using namespace std;
#define maxn 100010
#define maxt 330

int t,n,a[maxn],L[maxt],R[maxt],pos[maxn],la[maxt];
bool vis[maxt];
vector <int > e[maxt];

inline int read_() {
   int x_=0,f_=1;char c_=getchar();
   while(c_<'0'||c_>'9') {if(c_=='-') f_=-1;c_=getchar();}
   while(c_>='0'&&c_<='9') {x_=(x_<<1)+(x_<<3)+c_-'0';c_=getchar();}
   return x_*f_;
}

inline void resert_(int x) {
   e[x].clear();
   for(int i=L[x];i<=R[x];++i) e[x].push_back(a[i]);
   sort(e[x].begin(),e[x].end());
   vis[x]=0;
} 
inline void update_(int l,int r,int w) {
   int LL=pos[l],RR=pos[r];
   if(LL==RR) {
   	for(int i=l;i<=r;++i) a[i]+=w;
   	vis[LL]=1;
   }
   else {
   	for(int i=l;i<=R[LL];++i) a[i]+=w;
   	vis[LL]=1;
   	for(int i=L[RR];i<=r;++i) a[i]+=w;
   	vis[RR]=1;
   	for(int i=LL+1;i<=RR-1;++i) la[i]+=w;
   }
} 

inline int query_(int l,int r,int w) {
   int LL=pos[l],RR=pos[r];
   if(LL==RR) {
   	int ans=-1;
   	for(int i=l;i<=r;++i) {
   		if(a[i]+la[pos[i]]<w) {
   			ans=max(ans,a[i]+la[pos[i]]);
   		}
   	}
   	return ans;
   }
   else {
   	int ans=-1;
   	for(int i=l;i<=R[LL];++i) {
   		if(a[i]+la[pos[i]]<w) {
   			ans=max(ans,a[i]+la[pos[i]]);
   		} 
   	}
   	for(int i=L[RR];i<=r;++i) {
   		if(a[i]+la[pos[i]]<w) {
   			ans=max(ans,a[i]+la[pos[i]]);
   		}
   	}
   	for(int i=LL+1;i<=RR-1;++i) {
   		if(vis[i]) resert_(i);
   		int AKIOI=lower_bound(e[i].begin(),e[i].end(),w-la[i])-e[i].begin();
   		if(!AKIOI) continue;
   		ans=max(ans,e[i][AKIOI-1]+la[i]);
   	} 
   	return ans;
   }
}

void readda_() {
   n=read_();
   for(int i=1;i<=n;++i) a[i]=read_();
   t=sqrt(n);
   for(int i=1;i<=t;++i) {
   	L[i]=(i-1)*t+1;
   	R[i]=i*t;
   }
   if(R[t]<n) {++t;L[t]=R[t-1]+1;R[t]=n;}
   for(int i=1;i<=t;++i) {
   	for(int j=L[i];j<=R[i];++j) {
   		pos[j]=i;
   		e[i].push_back(a[j]);
   	}
   	sort(e[i].begin(),e[i].end());
   }
   for(int i=1;i<=n;++i) {
   	int pd=read_(),l=read_(),r=read_(),c=read_();
   	if(!pd) update_(l,r,c);
   	else printf("%d\n",query_(l,r,c));
   }
}

int main() {
   freopen("a.txt","r",stdin);
   readda_();
   return 0;
}
  • 当然，这个题想表达的思想是块内又可以用另一种数据结构来实现，所以块内部可以用 s e t set set来实现
#include <bits/stdc++.h>
using namespace std;
#define maxn 100010
#define maxt 330

int n,L[maxt],R[maxt],la[maxt],a[maxn],t,pos[maxn];
set <int > e[maxt];

inline int read_() {
	int x_=0,f_=1;char c_=getchar();
	while(c_<'0'||c_>'9') {if(c_=='-') f_=-1;c_=getchar();}
	while(c_>='0'&&c_<='9') {x_=(x_<<1)+(x_<<3)+c_-'0';c_=getchar();}
	return x_*f_;
}

inline void update_(int l,int r,int w) {
	int LL=pos[l],RR=pos[r];
	if(LL==RR) {
		for(int i=l;i<=r;++i) {
			e[LL].erase(a[i]);
			a[i]+=w;
			e[LL].insert(a[i]);
		} 
	}
	else {
		for(int i=l;i<=R[LL];++i) {
			e[LL].erase(a[i]);
			a[i]+=w;
			e[LL].insert(a[i]);
		} 
		for(int i=L[RR];i<=r;++i) {
			e[RR].erase(a[i]);
			a[i]+=w;
			e[RR].insert(a[i]);
		}
		for(int i=LL+1;i<=RR-1;++i) la[i]+=w;
	}
}

inline int query_(int l,int r,int w) {
	int LL=pos[l],RR=pos[r];
	if(LL==RR) {
		int ans=-1,AKIOI;
		for(int i=l;i<=r;++i) {
			AKIOI=a[i]+la[LL];
			if(AKIOI<w) ans=max(ans,AKIOI); 
		}
		return ans;
	}
	else {
		int ans=-1,AKIOI;
		for(int i=l;i<=R[LL];++i) {
			AKIOI=a[i]+la[LL];
			if(AKIOI<w) ans=max(ans,AKIOI);
		} 
		for(int i=L[RR];i<=r;++i) {
			AKIOI=a[i]+la[RR];
			if(AKIOI<w) ans=max(ans,AKIOI);
		}
		for(int i=LL+1;i<=RR-1;++i) {
			set<int> :: iterator it=e[i].lower_bound(w-la[i]); 
			if(it==e[i].begin()) continue;
			--it;
			ans=max(ans,*it+la[i]);
     	}
     	return ans;
	}
} 

void readda_() {
	n=read_();
	for(int i=1;i<=n;++i) a[i]=read_();
	t=sqrt(n);
	for(int i=1;i<=t;++i) {
		L[i]=(i-1)*t+1;
		R[i]=i*t;
	}
	if(R[t]<n) {++t;L[t]=R[t-1]+1;R[t]=n;}
	for(int i=1;i<=t;++i) {
		for(int j=L[i];j<=R[i];++j) {
			pos[j]=i;
			e[i].insert(a[j]);
		}
	}
	for(int i=1;i<=n;++i) {
		int pd=read_(),l=read_(),r=read_(),c=read_();
		if(!pd) update_(l,r,c);
		else printf("%d\n",query_(l,r,c));
	}
}

int main() {
	freopen("a.txt","r",stdin);
	readda_();
	return 0;
}

数列分块入门 4

  • 给出一个长为 n n n的数列，以及 n n n个操作，操作涉及区间加法，区间求和。
  • 每个块维护一个块的总和 s u m [ i ] sum[i] sum[i]
  • 修改时，不完整块暴力修改 a 和 s u m a和sum a和sum,完整块修改 l a z y lazy lazy
  • 询问时，不完整块暴力询问，完整块询问和，注意加上 l a z y ∗ 区 间 长 度 lazy*区间长度 lazy∗区间长度
  • 要开 l o n g long long l o n g long long
#include <bits/stdc++.h>
using namespace std;
#define maxn 50010
#define maxt 240

int n,L[maxt],R[maxt],pos[maxn],t;
long long a[maxn],sum[maxt],la[maxt];

inline long long read_() {
	long long x_=0,f_=1;char c_=getchar();
	while(c_<'0'||c_>'9') {if(c_=='-') f_=-1;c_=getchar();}
	while(c_>='0'&&c_<='9') {x_=(x_<<1)+(x_<<3)+c_-'0';c_=getchar();}
	return x_*f_;
}

inline void update_(int l,int r,int w) {
	int LL=pos[l],RR=pos[r];
	if(LL==RR) {
		for(int i=l;i<=r;++i) {
			a[i]+=w;
			sum[LL]+=w;
		} 
	}
	else {
		for(int i=l;i<=R[LL];++i) {
			a[i]+=w;
			sum[LL]+=w;
		}
		for(int i=L[RR];i<=r;++i) {
			a[i]+=w;
			sum[RR]+=w;
		}
		for(int i=LL+1;i<=RR-1;++i) la[i]+=w;
	}
}

inline long long query_(int l,int r) {
	int LL=pos[l],RR=pos[r];
	long long ans=0;
	if(LL==RR) {
		for(int i=l;i<=r;++i) ans+=a[i];	
		ans+=(r-l+1)*la[LL];
	}
	else {
		for(int i=l;i<=R[LL];++i) ans+=a[i];
		ans+=(R[LL]-l+1)*la[LL];
		for(int i=L[RR];i<=r;++i) ans+=a[i];
		ans+=(r-L[RR]+1)*la[RR];
		for(int i=LL+1;i<=RR-1;++i) {
			ans+=sum[i];
			ans+=(R[i]-L[i]+1)*la[i];
		}
	}
	return ans;
}

void readda_() {
	n=read_();
	for(int i=1;i<=n;++i) a[i]=read_();
	t=sqrt(n);
	for(int i=1;i<=t;++i) {
		L[i]=(i-1)*t+1;
		R[i]=i*t;
	}
	if(R[t]<n) {++t;L[t]=R[t-1]+1;R[t]=n;}
	for(int i=1;i<=t;++i) {
		for(int j=L[i];j<=R[i];++j) {
			pos[j]=i;
			sum[i]+=a[j];
		}
	}
	for(int i=1;i<=n;++i) {
		int pd=read_(),l=read_(),r=read_(),c=read_();
		if(!pd) update_(l,r,c);
		else printf("%lld\n",query_(l,r)%(c+1));
	} 
}

int main() {
	freopen("a.txt","r",stdin);
	readda_();
	return 0;
}

数列分块入门 5

  • 给出一个长为 n n n的数列 ，以及 n n n个操作，操作涉及区间开方，区间求和。
  • 修改：不是完整的块暴力修改，对于完整的块？我们也只能暴力修改，但如果块内元素都小于等于 1 1 1，就不用去修改了，而一个很大的数开方几次就到 1 1 1了，所以复杂度是能承受的。
  • 询问：不完整的块暴力询问，完整的块询问块的和
#include <bits/stdc++.h>
using namespace std;
#define maxn 50010
#define maxt 240

int n,a[maxn],L[maxt],R[maxt],sum[maxt],pos[maxn],t;
bool flag[maxt];

inline int read_() {
   int x_=0,f_=1;char c_=getchar();
   while(c_<'0'||c_>'9') {if(c_=='-') f_=-1;c_=getchar();}
   while(c_>='0'&&c_<='9') {x_=(x_<<1)+(x_<<3)+c_-'0';c_=getchar();}
   return x_*f_;
}

inline void solve_(int x) {
   if(flag[x]) return ;
   flag[x]=1;
   for(int i=L[x];i<=R[x];++i) {
   	sum[x]-=a[i];
   	a[i]=sqrt(a[i]);
   	sum[x]+=a[i];
   	if(a[i]>1) flag[x]=0; 
   }
}

inline void update_(int l,int r,int w) {
   int LL=pos[l],RR=pos[r];
   if(LL==RR) {
   	for(int i=l;i<=r;++i) {
   		sum[LL]-=a[i];
   		a[i]=sqrt(a[i]);
   		sum[LL]+=a[i];
   	}
   }
   else {
   	for(int i=l;i<=R[LL];++i){
   		sum[LL]-=a[i];
   		a[i]=sqrt(a[i]);
   		sum[LL]+=a[i];
   	}
   	for(int i=L[RR];i<=r;++i) {
   		sum[RR]-=a[i];
   		a[i]=sqrt(a[i]);
   		sum[RR]+=a[i];
   	}
   	for(int i=LL+1;i<=RR-1;++i) solve_(i);
   }
}

inline int query_(int l,int r) {
   int LL=pos[l],RR=pos[r];
   int ans=0;
   if(LL==RR) {
   	for(int i=l;i<=r;++i) ans+=a[i];
   }
   else {
   	for(int i=l;i<=R[LL];++i) ans+=a[i];
   	for(int i=L[RR];i<=r;++i) ans+=a[i];
   	for(int i=LL+1;i<=RR-1;++i) ans+=sum[i];
   }
   return ans;
}

void readda_() {
   n=read_();
   for(int i=1;i<=n;++i) a[i]=read_();
   t=sqrt(n);
   for(int i=1;i<=t;++i) {
   	L[i]=(i-1)*t+1;
   	R[i]=i*t;
   }
   if(R[t]<n) {++t;L[t]=R[t-1]+1;R[t]=n;}
   for(int i=1;i<=t;++i) {
   	for(int j=L[i];j<=R[i];++j) {
   		pos[j]=i;
   		sum[i]+=a[j];
   	}
   } 
   for(int i=1;i<=n;++i) {
   	int pd=read_(),l=read_(),r=read_(),c=read_();
   	if(!pd) update_(l,r,c);
   	else printf("%d\n",query_(l,r));
   }
}

int main() {
   freopen("a.txt","r",stdin);
   readda_();
   return 0;
}
小元勋
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
分块详解(优雅的暴力)
yyh_getAC的博客
09-14 3178
分块，顾名思义，就是把问题分成很多块，然后对每块单独求解，最终的答案就是每块的答案的并。 在信息学中，我们通常将分块定义为 把一个长度为 N 的序列分成若干块，然后对于每次在序列上的操作 ( 一般是区间的修改和查询)，我们们分别在操作设计的那些块上进行即可。 简单的来说，分块其实就是一种暴力的优化。
分块专题整理（分块+莫队）
qq_59498780的博客
10-04 666
分块1.什么是分块2.分块的作用与优缺点3.分块的一般步骤 1.什么是分块 说白了，分块就是优化的暴力。 例如，进行区间加法操作时，我们可以把序列分为若干个块，被全覆盖的块只需进行标记，再把没被全覆盖的进行暴力处理，进行大量大范围操作时区块相对暴力的优越性是显然的。 通常取每个块的大小为N\sqrt NN​，这样可以达到时空平衡，时间复杂度为 O((N+Q)∗log⁡N)O((N+Q) * \log N)O((N+Q)∗logN) 。 2.分块的作用与优缺点 与树状数组和线段树等数据结构的作用一样，分块是用
分块算法入门
SZTU_ZJB的博客
08-15 499
对于区间信息的整理，我们往往会用**树状数组**或者**线段树**，但在维护一些较为复杂的信息时，例如不满足区间可加、可减时就显得非常的吃力，代码实现起来也不那么简单、直观。 分块算法的基本思想是，通过适当的划分，预处理一些信息保存下来，用空间换取时间，从而达到时空平衡。 分块的思想是把数据分成若干块，为了时间复杂度的均摊，块的大小通常设置为 `sqrt(n) `，以块为单位维护区间的值。...
小总结-数据结构-分块
MYJ_aiie的博客
07-28 89
分块其实算是一种思想：把数据划分成几块，在块上预处理信息，询问时可以直接用。如果要在序列中询问一段区间的和，并且可能有增加区间的值。分块的时间复杂度和分的块的大小有密切关系，一般会设为。对于每个序列里的值，记录他们自己的值和所属的块。前面第一个整块中间的值。(图里的圈1和圈4）中间的整块的和加上（图里的圈2和圈3）。（所以查询散块的时候不要忘记把这部分加上）对于每个块，维护左右区间和和预处理的和。中间的整块的预处理的和加上要增加的值。左侧的散块原序列的变量加上要增加的值。的块，预处理每块的和。
分块最好的ppt
10-19
分块最好的ppt。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
.net 分块上传例子
04-01
在.NET开发环境中，分块上传是一种处理大文件上传的有效策略，尤其在处理超过单次请求限制的文件时显得尤为重要。这种技术将大文件分割成多个小块，然后逐个上传，确保了上传过程的稳定性和效率。下面我们将深入探讨...
分块算法文档
03-04
分块算法文档 分块算法是数据存储和重复查询的算法，它的核心思想是将大的数据块分割成小的块，并对每个块进行哈希处理，以便快速地検索和查找重复的数据块。下面是对分块算法的详细解释： 1. 数据分块：将大的...
基于图像分块DCT变换的压缩重构算法matlab仿真+仿真操作录像
10-14
《基于图像分块离散余弦变换（DCT）的压缩重构算法MATLAB仿真解析》 在信息技术领域，图像压缩是至关重要的一个环节，它能够有效地减少存储空间和传输带宽。基于图像分块的离散余弦变换（DCT）压缩算法是其中一种...
图像分块代码
11-28
在图像处理领域，分块是一种常见的技术，常用于图像压缩、图像分析以及图像特征提取等任务。本示例中，我们将深入探讨如何使用MATLAB语言实现图像的分块显示，以便更好地理解和操作图像数据。 首先，MATLAB是一种...
分块算法详解
12-19
讲解分块算法，分块算法在acm中的应用 一种暴力美学的算法
线性代数学习笔记——第七讲——分块矩阵（干货满满的感觉）
热门推荐
预见未来to50的专栏
08-15 8万+
1. 分块矩阵的基本概念 2. 分块法之一——分出特殊矩阵 （分块对角矩阵的概念） 3. 分块法之二——按列分块 （矩阵各元素为列向量） 4.分块法之三——按行分块 （矩阵各元素为行向量） 5. 分块矩阵的基本运算之分块加法 6.分块矩阵的基本运算之分块数乘 7.分块矩阵的基本运算之分块乘法 示例： 8. 由n维列向量构成的矩阵可...
【总结】分块
tanfuwen_的博客
02-08 305
0x00 写在前面 新年假期想学点东西，本着简单的想法，找了个感觉最简单的分块来学 近期目标：数列分块入门 尽量去做，另外做一些蓝到紫难度的题 0x01 分块是什么&&可以做什么 分块，顾名思义，就是把一个要维护的序列分成几个块来处理，要查询区间信息，就把区间拆分到块里，从而通过提取块内的信息达到降低时间复杂度的目的 做一个形象的比喻，科任老师要清作业，如果直接把全班的作业交上来数肯定会很累，于是科任老师分了个小组，小组长负责清出本组有多少人交，科任老师就只需要向每个小组长去询问，时间大
分块算法及其应用
playedgames的博客
09-25 262
分块算法的应用
分块大法
qq_38643745的博客
05-25 8343
所谓分块，就是将原序列处理成各个小块，目的是尽量地达到处理和询问之间的平衡。对于分块类问题，常常可以提取出“在给定区间内进行操作，或询问区间内满足给定条件的元素等”。接下来，例题。首先是男神hzwer的博客链接 hzwer 因为下述题目皆由此改变。问题 A: 小Z的课堂检测 时间限制: 1 Sec 内存限制: 128 MB 题目描述 大家都知道小Z的课总是十分快的（鬼知道为什么），然后我
[分块] 分块入门1~4
zero_orez6的博客
06-29 368
何为分块 在学习完线段树和树状数组后，这两种数据结构已经能够解决大部分的问题了，但在使用过程中不难发现他们的缺点 树状数组O((N+M)logN)O((N+M)logN)O((N+M)logN)：局限性过大，不易扩展到普遍性题目 线段树O((N+M)logN)O((N+M)logN)O((N+M)logN)：虽然能够扩展到许多题目，其也有许多类型，但不够直观，并且代码长,细节多… 分块应运而生 分块的基本思想是通过适当的划分，预处理一部分信息并保存下来，用空间换取时间，达到"时空平衡" ———《算法竞
算法基础——分块
m0_52766855的博客
04-09 952
分块的概念 分块算法用于是区间信息维护与查询的算法 分块的思想是把数据分成若干块，为了时间复杂度的均摊，块的大小通常设置为 n\sqrt nn​，以块为单位维护区间的值 对于单点更新，时间复杂度 O(1)O(1)O(1) 区间更新，若区间不跨越块，直接暴力处理，时间复杂度 O(n)O(\sqrt n)O(n​)，若跨越块，则不能凑成一个整块的暴力处理，整块的直接更新，时间复杂度 O(n)O(\sqrt n)O(n​) 区间查询同理 分块的特点：分块算法比较简洁，能够维护一些树状数组和线段树无法维护的值，但
分块pagerank
最新发布
12-09
分块Pagerank是一种将大规模的网页图分成多个块进行计算的Pagerank算法。下面是分块Pagerank的步骤： 1.将网页图分成多个块，每个块包含若干个网页节点。 2.对于每个块，计算其内部的Pagerank值。这可以使用常规的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值