分块入门

本文介绍了一种利用线段树进行数据结构分块的方法,通过将操作序列按根号n大小分块来提高处理效率,并针对单点查询、单点修改、区间修改和区间查询等操作进行了详细说明。此外,还提供了三道例题及其代码实现。

将长为n操作序列分成好几块

设定每块大小为根号n,这样就把序列分为了n/根号n块

对于每一块,整体处理,不能构成一块的,枚举处理

比如线段树的4个基本操作

4个数组,bl[]记录属于哪一块,a[]记录原值,sum_sum[]记录块内总和,sum_change[]记录这一块都怎么改

单点查询i:直接输出a[i]

单点修改(如果是加上某个数)i:既修改a[i],又要修改sum_sum[bl[i]]

区间修改[l,r](整体加上x):分3步

            ① x所在块,但要注意是从l到min(l所在块的最后一个,y)

                枚举,a[i]+x,sum_sum[bl[i]]+x

            ② x和y之间的块(不包括x,y所在块)

                一次性更改整个快,既sum_change[bl[i]]+x

            ③ y所在块,但要注意前提是x和y不在同一块内,

               枚举 a[i]+x,sum_sum[bl[i]]+x

区间查询(求和):也是分3步 分步情况与上面一样,不在叙述

             ① ans+=a[i]+sum_change[bl[i]]

             ② ans+=sum_sum[i]+sum_change[i]*根号n

             ③ ans+=a[i]+sum_change[bl[i]]

即将答案分为2部分,中间在块内的、两边不能构成一块的

 

以下3题练练手

T1 http://codevs.cn/problem/1080/ 线段树练习  单点修改+区间查询

#include<cstdio>
#include<cmath>
#include<algorithm>
#define N 100001
using namespace std;
int n,m,t;
int sum[350],a[N],bl[N];
int query(int x,int y)
{
    int cur=0;
    for(int i=x;i<=min(bl[x]*t,y);i++) cur+=a[i];
    for(int i=bl[x]+1;i<bl[y];i++) cur+=sum[i];
    if(bl[x]!=bl[y])
    for(int i=(bl[y]-1)*t+1;i<=y;i++) cur+=a[i];
    return cur; 
}
int main()
{
    scanf("%d",&n);
    t=sqrt(n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        bl[i]=(i-1)/t+1;
        sum[bl[i]]+=a[i];
    }
    scanf("%d",&m);
    int x,y,z;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        if(x==1)
        {
            a[y]+=z;
            sum[bl[y]]+=z;
        }
        else printf("%d\n",query(y,z));
    }
}
View Code

T2 http://codevs.cn/problem/1081/ 线段树练习2  单点查询+区间修改

#include<cstdio>
#include<cmath>
#include<algorithm>
#define N 100001
using namespace std;
int n,m,t;
int sum[350],a[N],bl[N];
int main()
{
    scanf("%d",&n);
    t=sqrt(n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        bl[i]=(i-1)/t+1;
    }
    scanf("%d",&m);
    int x,y,z,p;
    for(int k=1;k<=m;k++)
    {
        scanf("%d",&p);
        if(p==1)
        {
            scanf("%d%d%d",&x,&y,&z);
            for(int i=x;i<=min(y,bl[x]*t);i++) a[i]+=z;
            for(int i=bl[x]+1;i<bl[y];i++) sum[i]+=z;
            if(bl[x]!=bl[y])
            for(int i=(bl[y]-1)*t+1;i<=y;i++) a[i]+=z; 
        }
        else 
        {
            scanf("%d",&x);
            printf("%d\n",a[x]+sum[bl[x]]);
        }
    }
}
View Code

T3 http://codevs.cn/problem/1082/ 线段树练习3 区间修改+区间查询

#include<cstdio>
#include<cmath>
#include<algorithm>
#define N 200001
using namespace std;
int n,m,t,bl[N];
long long sum_change[500],a[N],sum_sum[500];
int main()
{
    scanf("%d",&n);
    t=sqrt(n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
        bl[i]=(i-1)/t+1;
        sum_sum[bl[i]]+=a[i];
    }
    scanf("%d",&m);
    int x,y,z,p;
    for(int k=1;k<=m;k++)
    {
        scanf("%d",&p);
        if(p==1)
        {
            scanf("%d%d%d",&x,&y,&z);
            for(int i=x;i<=min(y,bl[x]*t);i++) a[i]+=z,sum_sum[bl[i]]+=z;
            for(int i=bl[x]+1;i<bl[y];i++) sum_change[i]+=z;
            if(bl[x]!=bl[y])
            for(int i=(bl[y]-1)*t+1;i<=y;i++) a[i]+=z,sum_sum[bl[i]]+=z; 
        }
        else 
        {
            long long cur=0;
            scanf("%d%d",&x,&y);
            for(int i=x;i<=min(y,bl[x]*t);i++) cur+=a[i]+sum_change[bl[i]];
            for(int i=bl[x]+1;i<bl[y];i++) cur+=sum_sum[i]+sum_change[i]*t;
            if(bl[x]!=bl[y]) 
            for(int i=(bl[y]-1)*t+1;i<=y;i++) cur+=a[i]+sum_change[bl[i]];
            printf("%lld\n",cur);
        }
    }
}
View Code

 

转载于:https://www.cnblogs.com/TheRoadToTheGold/p/6552462.html

### 数列分块入门第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; } ``` 通过以上步骤即可有效应对数列分块相关的题目需求。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值