『分块算法初步』

最新推荐文章于 2024-07-20 22:34:59 发布
最新推荐文章于 2024-07-20 22:34:59 发布
阅读量62 收藏 1
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Parsnip/p/10458689.html
版权

分块

分块查找是折半查找和顺序查找的一种改进方法，分块查找由于只要求索引表是有序的，对块内节点没有排序要求，因此特别适合于节点动态变化的情况。

分块其实可以说是一种偏数据结构类的通用型算法吧，没有很艰深的内容，与暴力最为相似，但是在很多题目中都能派上很好的用场。

我们可以先通过一道模板例题来了解分块。

Description

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

Solution

这道题当然可以用树状数组，线段树等经典的数据结构来解决，我们现在来谈一谈分块的做法。

分块就是讲原本序列中的n个数"打包"分为\(sqrt(n)\)个块，对于区间的操作，我们可以对每一个块进行标记处理，等到查询时再检查是否有更新记录，利用类似于这样的思想来优化时间复杂度。

具体的，我们可以这样做。

1.使\(t=sqrt(n)\)，将原序列分为\(t\)个块，其中，第\(i\)个块的覆盖范围为\([(i-1)*t+1,i*t]\)
2.对于最后剩下不完全的部分，额外的分一个块，其范围为\([n-\lfloor{\frac{n}{t}}\rfloor*t+1,n]\)
3.预处理一个数组\(pos[i]\)，代表第\(i\)个元素所在块的下标
4.对于区间加法操作，区间包含的部分一定为若干个完整的块(可能\(0\)个)和至多两个不完整的块，对于不完整的块，我们可以暴力扫描进行加法更新，对于完整的块\(i\)，我们可以令\(changed[i]+=delta\)，表示第i个块有一个整体的\(+delta\)更新操作，先记录下来。
5.对于查询操作，我们可以直接返回\(a[x]+change[pos[x]]\)。

这就是分块算法的基本流程，引用\(lyd\)大佬一句话来形容，就是大段维护，局部朴素，可以认为是暴力的优化，具有较好的直观性，代码量不长，容易拓展。

\(Code:\)

#include<bits/stdc++.h>
using namespace std;
const int N=100000+200,M=100000+200,sqrtN=400;
int n,t,L[sqrtN],R[sqrtN],pos[N];
long long changed[sqrtN],a[N];
inline void input(void)
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%lld",&a[i]);
}
inline void init(void)
{
    t=sqrt(n);
    for(int i=1;i<=t;i++)
    {
        L[i]=(i-1)*sqrt(n)+1;
        R[i]=i*sqrt(n);
    }
    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;
} 
inline void change(int l,int r,long long delta)
{
    int p=pos[l],q=pos[r];
    if(p==q)
        for(int i=l;i<=r;i++)a[i]+=delta;
    else
    {
        for(int i=p+1;i<=q-1;i++)
            changed[i]+=delta;
        for(int i=l;i<=R[p];i++)
            a[i]+=delta;
        for(int i=L[q];i<=r;i++)
            a[i]+=delta;
    }
}
inline long long ask(int x)
{
    return a[x]+changed[pos[x]];
}
inline void solve(void)
{
    int index,l,r;long long delta;
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d%d%lld",&index,&l,&r,&delta);
        if(!index)
            change(l,r,delta);
        else printf("%lld\n",ask(r));
    }
} 
int main(void)
{ 
    input();
    init();
    solve();
    return 0;
}

Description

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

Solution

这道题就是分块算法的简单拓展，对原来算法进行简单的改进就可以解决该问题。

除了增量标记外，每一个块我们额外维护一个有序序列。用\(vector\)储存每一个块的有序序列并直接利用\(sort\)排序即可。

对于区间加法，整块的部分直接累加增量标记，非整块的部分暴力修改单点权值，并对部分修改的块重置有序序列即可。
对于查询，整块的部分直接二分查找有序序列中大小第一个大于等于\(c*c-change[i]\)的部分，数量即为该位置减掉数组首地址，累加每一个整块的数量即可，非整块的部分暴力统计即可累加答案。

\(Code:\)

#include<bits/stdc++.h>
using namespace std;
const int N=50000+200,M=50000+200,sqrtN=300;
int n,t,L[sqrtN],R[sqrtN],pos[N];
int changed[sqrtN],a[N];
vector < int > section[sqrtN];
inline void input(void)
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
}
inline void reset(int x)
{
    section[x].clear();
    for(int i=L[x];i<=R[x];i++)
        section[x].push_back(a[i]);
    sort(section[x].begin(),section[x].end()); 
}
inline void init(void)
{
    t=sqrt(n);
    for(int i=1;i<=t;i++)
    {
        L[i]=(i-1)*sqrt(n)+1;
        R[i]=i*sqrt(n);
    }
    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<=t;i++)
        reset(i);
}
inline void change(int l,int r,int delta)
{
    int p=pos[l],q=pos[r];
    if(p==q)
    {
        for(int i=l;i<=r;i++)
            a[i]+=delta;
        reset(p);
    }
    else
    {
        for(int i=l;i<=R[p];i++)
            a[i]+=delta;
        reset(p);
        for(int i=L[q];i<=r;i++)
            a[i]+=delta;
        reset(q);
        for(int i=p+1;i<=q-1;i++)
            changed[i]+=delta; 
    }
} 
inline int ask(int l,int r,int limit)
{
    int p=pos[l],q=pos[r];
    int ans=0;
    if(p==q)
    {
        for(int i=l;i<=r;i++)
            if(a[i]+changed[p]<limit)ans++;
    }
    else
    {
        for(int i=l;i<=R[p];i++)
            if(a[i]+changed[p]<limit)ans++;
        for(int i=L[q];i<=r;i++)
            if(a[i]+changed[q]<limit)ans++;
        for(int i=p+1;i<=q-1;i++)
            ans+=lower_bound(section[i].begin(),section[i].end(),limit-changed[i])-section[i].begin();
    }
    return ans;
}
inline void solve(void)
{
    int l,r,index;int delta;
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d%d%d",&index,&l,&r,&delta);
        if(!index)
            change(l,r,delta);
        else printf("%d\n",ask(l,r,delta*delta)); 
    }
}
int main(void)
{
    input();
    init();
    solve();
    return 0;
}

Description

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

Solution

这道题其实和第二题类似，也是维护每一个块的区间有序性，前驱直接二分查找即可。

\(Code:\)

#include<bits/stdc++.h>
using namespace std;
const int N=100000+200,sqrtN=400;
const long long INF=LONG_LONG_MAX;
int n,t,L[sqrtN],R[sqrtN],pos[N];
long long changed[sqrtN],a[N];
vector < long long > section[sqrtN];
inline void input(void)
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%lld",&a[i]);
}
inline void reset(int x)
{
    section[x].clear();
    for(int i=L[x];i<=R[x];i++)
        section[pos[i]].push_back(a[i]);
    sort(section[x].begin(),section[x].end());
}
inline void init(void)
{
    t=sqrt(n);
    for(int i=1;i<=t;i++)
    {
        L[i]=(i-1)*sqrt(n)+1;
        R[i]=i*sqrt(n);
    }
    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<=t;i++)
        reset(i);
}
inline void change(int l,int r,long long delta)
{
    int p=pos[l],q=pos[r];
    if(p==q)
    {
        for(int i=l;i<=r;i++)
            a[i]+=delta;
        reset(p);
    }
    else
    {
        for(int i=l;i<=R[p];i++)
            a[i]+=delta;
        reset(p);
        for(int i=L[q];i<=r;i++)
            a[i]+=delta;
        reset(q);
        for(int i=p+1;i<=q-1;i++)
            changed[i]+=delta;
    }
}
inline void updata(long long &ans,long long val,long long limit)
{
    if(val<limit&&val>ans)ans=val;
}
inline long long ask(int l,int r,long long limit)
{
    int p=pos[l],q=pos[r];
    long long ans=-1;
    if(p==q)
    {
        for(int i=l;i<=r;i++)
            updata(ans,a[i]+changed[pos[i]],limit);
    }
    else
    {
        for(int i=l;i<=R[p];i++)
            updata(ans,a[i]+changed[pos[i]],limit);
        for(int i=L[q];i<=r;i++)
            updata(ans,a[i]+changed[pos[i]],limit);
        for(int i=p+1;i<=q-1;i++)
            updata(ans,section[i][lower_bound(section[i].begin(),section[i].end(),limit-changed[i])-section[i].begin()-1]+changed[i],limit);
    }
    return ans;
}
inline void solve(void)
{
    int l,r,index;long long delta;
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d%d%lld",&index,&l,&r,&delta);
        if(!index)
            change(l,r,delta);
        else printf("%lld\n",ask(l,r,delta)); 
    }
}
int main(void)
{
    input();
    init();
    solve();
    return 0;
}

Description

给出一个长为\(n\)的数列，以及\(n\)个操作，操作涉及区间加法，区间求和。

Solution

这道题的拓展也是比较典型的。我们只需要再维护每一块的权值和就可以快速的解决查询问题，对于权值和的更新，只需要对每一次加法操作是进行顺带更新即可。

\(Code:\)

#include<bits/stdc++.h>
using namespace std;
const int N=100000+200,M=100000+200,sqrtN=400;
int n,t,L[sqrtN],R[sqrtN],pos[N];
long long changed[sqrtN],sum[sqrtN],a[N];
inline void input(void)
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%lld",&a[i]);
}
inline void init(void)
{
    t=sqrt(n);
    for(int i=1;i<=t;i++)
    {
        L[i]=(i-1)*sqrt(n)+1;
        R[i]=i*sqrt(n);
    }
    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];
} 
inline void change(int l,int r,long long delta)
{
    int p=pos[l],q=pos[r];
    if(p==q)
    {
        for(int i=l;i<=r;i++)a[i]+=delta;
        sum[p]+=delta*(r-l+1);
    }
    else
    {
        for(int i=p+1;i<=q-1;i++)
            changed[i]+=delta;
        for(int i=l;i<=R[p];i++)
            a[i]+=delta;
        sum[p]+=delta*(R[p]-l+1);
        for(int i=L[q];i<=r;i++)
            a[i]+=delta;
        sum[q]+=delta*(r-L[q]+1); 
    }
}
inline long long ask(int l,int r,long long mod)
{
    int p=pos[l],q=pos[r];
    long long ans=0;
    if(p==q)
    {
        for(int i=l;i<=r;i++)ans+=a[i];
        ans+=changed[p]*(r-l+1);
        ans%=mod;
    }
    else
    {
        for(int i=p+1;i<=q-1;i++)
            ans+=sum[i]+changed[i]*(R[i]-L[i]+1),ans%=mod;
        for(int i=l;i<=R[p];i++)
            ans+=a[i],ans%=mod;
        ans+=changed[p]*(R[p]-l+1),ans%=mod;
        for(int i=L[q];i<=r;i++)
            ans+=a[i],ans%=mod;
        ans+=changed[q]*(r-L[q]+1),ans%=mod;
    }
    return ans;
}
inline void solve(void)
{
    int l,r,index;long long delta;
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d%d%lld",&index,&l,&r,&delta);
        if(!index)
            change(l,r,delta);
        else printf("%lld\n",ask(l,r,delta+1)%(delta+1));
    }
} 
int main(void)
{
    input();
    init();
    solve();
    return 0;
}

总结

分块算法可以说是一种优雅的暴力优化，在处理区间问题上有很大的帮助，通过对几道例题的认识，我们可以归纳得到如下要点：

  • 是否可以用分块算法？区间问题，具有整体维护的可行性
  • 使用分块算法需要考虑的问题？1.如何预处理 2.如何处理不完整的块 3.如何维护完整的块

转载于:https://www.cnblogs.com/Parsnip/p/10458689.html

weixin_33726313
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
分块查找算法实现
03-31
分块查找算法是一种在大规模数据集合中提高查找效率的策略，它是对传统顺序查找方法的优化。在传统的顺序查找中，我们需要线性遍历整个数据序列来查找目标元素，这在数据量大时效率较低。分块查找通过将数据划分为较...
易语言文本相似算法模块
07-18
例如，可以先使用`Take_Text`截取两段文本的关键部分，然后用`Text_Compare`进行初步比较，如果发现有相似的部分，再进一步使用`IsDBCSLeadByte`确保在处理多字节字符时的准确性。最后，可以采用更高级的算法，如TF-...
分块算法详解
a1351937368的博客
11-02 2589
【快速处理】分块算法 分块算法 ———————————————————- 1.思想 如果我们需要对一个特定的序列进行操作，那么非常直观、简单的方法就是纯暴力（不，那叫模拟）。 不过如果暴力能过的话，那就呵呵了。 所以我们要想一些比较高能的数据结构——分块。 相比线段树来说，分块算法比较难实现，但是只要深入理解，就可以实现了
分块算法入门：这次菜鸟真的看得懂！
Stagflation的博客
02-12 681
2020.2.11 #写在前面的话： 庚子鼠年，楚地大疫，皆无舟车，举城闭户。然四海同心，九州一力，同仇敌忾。有医名曰南山，带白甲千万，御雷火二神兽，力挽狂澜，战数月，灭疫千里，国泰民安。太史公曰，至此千年，天下之幸，非仗天地庇佑，乃仁治而得太平，医者无私，军民无畏，至此，华夏一族，当立万年！ **致敬医务工作者们！！**游子在外，没能帮上太大的忙，哪怕是一起面对，我很惭愧。希望那边快点好起来...
实现分块查找的算法
GJG666的博客
12-07 9365
输出顺序表（8,14,6,9,10,22,34,18,19，31,40，38,54,66,46,71,78,68,80,85,100,94,88,96,87）中采用分块查找的方法查找（每块的块长为5，共有5块）关键字46的过程。#include <stdio.h> #define MAXL 100 //定义表中最多记录个数 #define MAXI 20
分块算法
yanga11ang的博客
07-17 2483
感觉分块是一种很蛋疼的算法，但据说有的时候很好用 ( 分块算法可以维护一些线段树维护不了的东西，例如单调队列等，线段树能维护的东西必须能够进行信息合并，而分块则不需要 )。分块算法很多时候会把复杂度优化一个O( )。优化方式如下 一个规模为n 的问题， 我们将其变得有序， 令 x= 那么 我们可以将其划分为 块区域，分别为 [1 x] [x+1 2x] [2x+1 3x] ……[kx n
分块算法介绍(分块入门练习-1)
Hardict的算法日记
09-06 1707
前言 之前只了解分块,但没有深入学习.但之前集训时遇到http://codeforces.com/gym/100960/problem/G,当时现场树状数组没有调出来,赛后写出后上网搜其他方法,发现了一个奇妙的分块方法,便决定抽空深入学习一下这种优化的暴力——分块.  关键名词: 区间：一段连续子序列 区间操作：对某个区间进行同类型相同规模的操作 块：将一个数列划分为连续的块分块算法一般...
C++算法 - 分块思想初步
LNY2022的博客
03-25 399
分块的基本思想是，通过对原数据的适当划分，并在划分后的每一个块上预处理部分信息，从而较一般的暴力算法取得更优的时间复杂度。分块的时间复杂度主要取决于分块的块长，一般可以通过均值不等式求出某个问题下的最优块长，以及相应的时间复杂度。分块是一种很灵活的思想，相较于树状数组和线段树，分块的优点是通用性更好，可以维护很多树状数组和线段树无法维护的信息。当然，分块的缺点是渐进意义的复杂度，相较于线段树和树状数组不够好。不过在大多数问题上，分块仍然是解决这些问题的一个不错选择。
【算法】分块初步详解
Reimia的博客
11-27 3114
一.概念     分块算法，顾名思义，就是把问题分成多个块，然后按块来解决问题。适用的范围很广，通常是用在单点查询和某一区间的加减乘除。说白了，就是另类的一种暴力算法罢了 二.分块的编写 通过例题来讲解会更容易理解点，也便于我写编写的思路 例子很简单，给定一组数据num[]={1，2，3，4，5，6，7，8，9，10，11，12，13，14，15，16}，求在[2，9]范围内都加上一个数 2，然后查询num[5]的值 1.块的长度 在分块算法中，我们通常都是设每一个块
算法初步学习
mingbo64的博客
06-07 146
算法： 数据结构中的算法，指的是数据结构所具备的功能 解决特定问题的方法，它是前辈们的一些优秀的经验总结 输入：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件； 输出：一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的； 确定性：算法中的每一条指令必须有确切的含义，不能产生多义性： 可行性：算法中的每一条指令必须是切实可执行的，即原则上可以通过已经实现的基本运算执行有限次来实现（也称之为有效性）； 有穷性：算法必须能在有限步后终止
CO-OFDM系统中分块拉格朗日插值的CKF相位噪声补偿算法.docx
02-23
为了解决这一问题，文中提出了一种基于分块次符号二阶拉格朗日插值（BSSLI）的容积卡尔曼滤波（CKF）相位噪声补偿算法。首先，利用导频符号（pilot symbols）对时域OFDM符号的相位噪声进行初步估计，这一步是通过...
信息熵加权的HOG特征提取算法研究.pdf
05-11
本文提出了一种信息熵加权的 HOG 特征提取方法，该方法将待识别的人脸图像进行分块，对分块后的图像进行 HOG 特征提取，计算每块图像所含的信息熵作为权重系数加到各个分块中形成新的 HOG 特征，然后通过 PCA 算法对...
tin三角网算法实现源码
06-07
2. **数据预处理**：对输入的高程点进行排序或分块，以便于后续处理。可以使用二叉堆、K-D树等数据结构来快速查找最近邻点。 3. **构建初步三角网**：通过连接相邻的高程点，生成初始的三角形网格。最简单的算法是...
leetcode hot100 （面试复习用）
大厂小码农的博客
07-20 553
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。输入：nums = [5,7,7,8,8,10], target = 8输出：[3,4]// 继续向左查找} else {// 查找目标值在数组中的结束位置// 继续向右查找} else {
【LeetCode】分隔链表
最新发布
qq_26521261的博客
07-20 262
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 210
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
代码随想录打卡第二十九天
weixin_48013375的博客
07-19 412
day 29 贪心算法第三天。
二叉排序树与查找算法解析
教学目标包括熟练掌握顺序查找、折半查找、分块查找的算法及其分析，精通二叉排序树的构造、查找、插入和删除算法，并理解其性能分析。此外，还要初步了解平衡二叉排序树，如AVL树和红黑树，它们通过保持树的平衡来...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值