分块入门

分块算法实践

分块入门 1

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

没啥说的直接上程序

#include <bits/stdc++.h>
#define rep(x, y, z) for(register int x = y; x <= z; x ++) 
inline int read(){
    char ch = getchar(); int u = 0, f = 1;
    while (!isdigit(ch)){ if (ch == '-') f = -1; ch = getchar();}
    while (isdigit(ch)) {u = (u << 3) + (u << 1) + ch - 48; ch = getchar();}
    return u * f;
}
const int maxn = 500500;
int n, m, blo;
int v[maxn], tag[maxn], bl[maxn];
namespace Blo{//分块
    inline void Add(int l, int r, int c){
        rep (i, l, std::min(bl[l] * blo, r))
            v[i] += c;
        if (bl[l] != bl[r])
        rep (i, (bl[r] - 1) * blo + 1, r)
            v[i] += c;
        rep (i, bl[l] + 1, bl[r] - 1)
            tag[i] += c;
    }
    inline int query(int pos){//查询的时候就返回单点+块的标记
        return v[pos] + tag[bl[pos]];
    }
}
int main(){
    n = read(), m = read(); blo = sqrt(n);//块的大小
    for (int i = 1; i <= n; i++) bl[i] = (i - 1)/blo + 1;
    for (int i = 1; i <= n; i++) v[i] = read();
    while (m--){
        int opt = read();
        if (opt == 1) {int l = read(), r = read(), c = read(); Blo::Add(l, r, c);} 
        else {
            int x = read();
            printf("%d\n",Blo::query(x));
        }
    }
    return 0;
}

分块入门 2

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

每个块内用vector维护排序,注意细节的处理

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<vector>
#define int long long 
using namespace std;
int n,t,a,b,c,opt;
int L[501],R[501],post[50010],val[50010],mark[501];
vector<int>linker[510];
void add(int a,int b,int c)
{
	int p=post[a],q=post[b];
	if(p==q)
	{
		linker[p].clear();
		for(int i=a;i<=b;i++)
			val[i]+=c;
		for(int i=L[p];i<=R[p];i++)
			linker[p].push_back(val[i]);
		sort(linker[p].begin(),linker[p].end());
		return;
	}
	else
	{
		for(int i=p+1;i<=q-1;i++)
			mark[i]+=c;
		linker[p].clear();
		linker[q].clear();
		for(int i=a;i<=R[p];i++)
			val[i]+=c;
		for(int i=L[q];i<=b;i++)
			val[i]+=c;
		for(int i=L[p];i<=R[p];i++)
			linker[p].push_back(val[i]);
		for(int i=L[q];i<=R[q];i++)
			linker[q].push_back(val[i]);
		sort(linker[p].begin(),linker[p].end());
		sort(linker[q].begin(),linker[q].end());
		return;
	}
}
int query(int a,int b,int c)
{
	int ans=0;
	int p=post[a],q=post[b];
	if(p==q)
	{
		for(int i=a;i<=b;i++)
			if(val[i]+mark[p]<c)
				ans++;
	}
	else
	{
		for(int i=a;i<=R[p];i++)	
			if(val[i]+mark[p]<c)
				ans++;
		for(int i=L[q];i<=b;i++)	
			if(val[i]+mark[q]<c)
				ans++;
		for(int i=p+1;i<=q-1;i++)
		{
			int x=c-mark[i];
			ans+=lower_bound(linker[i].begin(),linker[i].end(),x)-linker[i].begin();
		}
	}
	return ans;
}
main()
{
	scanf("%lld",&n);
	int t=sqrt(n);
	for(int i=1;i<=n;i++)
		scanf("%lld",&val[i]);
	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++)
		{
			post[j]=i;
			linker[i].push_back(val[j]);
		}
		sort(linker[i].begin(),linker[i].end());
	}
	for(int i=1;i<=n;i++)
	{
		scanf("%lld%lld%lld%lld",&opt,&a,&b,&c);
		if(opt==0)
			add(a,b,c);
		else
			printf("%lld\n",query(a,b,c*c));
	}
	return 0;
}

程序



### 数列分块入门第8题的算法实现与解析 数列分块是一种高效的处理区间查询和修改的技术,其核心思想是将数组划分为若干个连续的小块,每一块内的元素可以快速更新或查询。对于数列分块入门第8题,假设问题是涉及区间加法操作以及最大值查询,则可以通过以下方法来解决。 #### 1. 数据结构设计 为了高效完成区间加法和最大值查询的操作,我们可以维护两个辅助数组: - `block_sum[]`:存储每个块的最大值。 - `lazy_tag[]`:标记每个块是否有延迟更新(即尚未应用到具体元素上的增量)。 这些数据结构的设计使得我们可以在 $ O(\sqrt{n}) $ 的时间复杂度下完成单次操作[^3]。 #### 2. 初始化过程 初始化时,我们需要计算初始状态下的块划分情况,并填充上述辅助数组的内容。以下是具体的代码实现: ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 1e5 + 5; int a[MAXN], block_size, block_num; long long block_max[400]; bool lazy_flag[400]; void build_block(int n) { block_size = sqrt(n); block_num = (n + block_size - 1) / block_size; memset(block_max, 0, sizeof(block_max)); memset(lazy_flag, false, sizeof(lazy_flag)); for (int i = 0; i < n; ++i) { int idx = i / block_size; block_max[idx] = max(block_max[idx], (long long)a[i]); } } ``` #### 3. 延迟标记的应用 当执行区间加法时,为了避免逐一遍历整个范围中的每一个元素,引入懒惰传播机制。如果某个整块完全被覆盖在当前操作范围内,则直接对该块打上标签并记录增量;否则逐一访问该块内部受影响的部分。 下面是针对这一逻辑的具体函数定义: ```cpp // Apply the pending update to all elements within specified block. void propagate(int blk_idx, int delta) { if (!lazy_flag[blk_idx]) return; // Update maximum value of this block accordingly. block_max[blk_idx] += delta * block_size; lazy_flag[blk_idx] = false; } // Add 'delta' to range [l, r]. void add_range(int l, int r, int delta, int n) { int start_blk = l / block_size, end_blk = r / block_size; if (start_blk == end_blk) { for (int i = l; i <= min(r, (start_blk + 1) * block_size - 1); ++i) a[i] += delta; // Recalculate new maximum after modification. block_max[start_blk] = 0; for (int i = start_blk * block_size; i < ((start_blk + 1) * block_size && i < n); ++i) block_max[start_blk] = max((long long)a[i], block_max[start_blk]); } else { // Process first incomplete block separately. for (int i = l; i < (start_blk + 1) * block_size; ++i) a[i] += delta; block_max[start_blk] = 0; for (int i = start_blk * block_size; i < ((start_blk + 1) * block_size && i < n); ++i) block_max[start_blk] = max((long long)a[i], block_max[start_blk]); // Fully covered blocks can simply apply tag updates. for (int b = start_blk + 1; b < end_blk; ++b){ block_max[b] += delta * block_size; lazy_flag[b] |= true; } // Handle last partial block similarly as above case. for (int i = end_blk * block_size; i <= r; ++i) a[i] += delta; block_max[end_blk] = 0; for (int i = end_blk * block_size; i < ((end_blk + 1) * block_size && i < n); ++i) block_max[end_blk] = max((long long)a[i], block_max[end_blk]); } } ``` #### 4. 查询最值功能 最后一步是在给定区间内查找最大的数值。这同样依赖于之前构建好的块级信息来进行加速检索。 ```cpp long long query_max(int l, int r) { int start_blk = l / block_size, end_blk = r / block_size; long long result = LLONG_MIN; if (start_blk == end_blk) { for (int i = l; i <= r; ++i) result = max(result, (long long)a[i]); } else { for (int i = l; i < (start_blk + 1) * block_size; ++i) result = max(result, (long long)a[i]); for (int b = start_blk + 1; b < end_blk; ++b) result = max(result, block_max[b]); for (int i = end_blk * block_size; i <= r; ++i) result = max(result, (long long)a[i]); } return result; } ``` 通过以上步骤即可有效应对数列分块相关的题目需求。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值