分块笔记&训练

于 2021-07-11 22:39:11 发布
阅读量143 收藏 1
点赞数
分类专栏： 《算法训练营》进阶篇读书笔记 数据结构 文章标签： 算法 数据结构 分治算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C_eeking/article/details/118643007
版权

分块

算法思想

树状数组和线段树维护的信息必须满足信息合并特性，分块算法可以维护一些线段树维护的内容，分块算法为优化后的暴力算法，几乎可以解决所有区间更新和区间查询

单点更新: 一般先将对应块懒标记下传，再暴力更新块状态

区间更新: 若区间更新横跨若干块，则只需对完全覆盖块打上懒标记，最多需要修改两端两个块，对两端剩余部分暴力更新

区间查询: 与区间更新类似，无需修改操作

预处理

将序列分块，然后每个块都标记左右端点L[i]和R[i]，对最后一块特别处理，一般每块大小为给定范围n的算术平方根

代码如下

t=sqrt(n);
int num=n/t;
if(n%t) num++;
for(int i=1;i<=num;i++)
{
	L[i]=(i-1)*t+1;
	R[i]=i*t;
}
R[num]=n;

用pos标记每个元素所属的块，用sum累加每一块的值(这里以求区间和为例子)

代码如下

for(int i=l;i<=num;i++)
	for(int j=L[i];j<=R[i];j++)
	{
		pos[j]=i;
		sum[i]+=a[j];
	}

区间更新

以[l,r]区间都加上d为例

  1. 求l和r所属块，p=pos[l],q=pos[r]
  2. 属于同一块，暴力更新
  3. 不属于同一块，完全覆盖区打标记，首尾暴力更新

代码如下

void Update(int l,int r,int d)
{
	int p=pos[l],q=pos[r];
	if(p==q)
	{
		for(int i=l;i<=r;i++)
			a[i]+=d;
		sum[p]+=d*(r-l+1);
	}
	else
	{
		for(int i=p+1;i<=q-1;i++)
			add[i]+=d;
		for(int i=l;i<=R[l];i++)
			a[i]+=d;
		sum[p]=d*(R[p]-l+1);
		for(int i=L[q];i<=r;i++)
			a[i]+=d;
		sum[q]+=d*(r-L[q]+1);
	}
}

区间查询

以查询[l,r]元素和为例

  1. 求l和r所属块，p=pos[l],q=pos[r]
  2. 若属于同一块，暴力累加，加上标记
  3. 不属于同一块，完全覆盖区域累加sum和标记值，暴力累加首尾端

代码如下

int Query(int l,int r)
{
	int p=pos[l],q=pos[r],ans=0;
	if(p==q)
	{
		for(int i=l;i<=r;i++)
			ans+=a[i];
		add+=add[p]*(r-l+1);
	}
	else
	{
		for(int i=p+1;i<=q-1;i++)
			ans+=sum[i]+add[i]*(R[i]-L[i]+1);
		for(int i=l;i<=R[p];i++)
			ans+=a[i];
		ans+=add[p]*(R[p]-l+1);
		for(int i=L[q];i<=r;i++)
			ans+=a[i];
		ans+=add[q]*(r-L[q]+1);
	}
	return ans;
}

训练

POJ3468

题目大意：N个数，两种操作，区间添加给定数和输出区间和

思路：分块算法完成区间修改和区间查询

代码

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long ll;
ll N,data[121212],Q,sum[121212],pos[121212],L[121212],R[121212],add[121212];
void Update(int l,int r,ll d ) {//更新l~r的数值
    int p=pos[l],q=pos[r];
    if(p==q) {//如果更新的是单个块，暴力
        for(int i=l; i<=r; i++)
            data[i]+=d;
        sum[p]+=d*(r-l+1);
    } else {
        for(int i=p+1; i<=q-1; i++)//头尾之间更新标记
            add[i]+=d;
        for(int i=l; i<=R[p]; i++)//头单独暴力
            data[i]+=d;
        sum[p]+=d*(R[p]-l+1);
        for(int i=L[q]; i<=r; i++)//尾单独暴力
            data[i]+=d;
        sum[q]+=d*(r-L[q]+1);
    }
}
ll Query(int l,int r) {
    int p=pos[l],q=pos[r];
    ll ans=0;
    if(p==q) {
        for(int i=l; i<=r; i++)
            ans+=data[i];
        ans+=add[p]*(r-l+1);
    } else {
        for(int i=p+1; i<=q-1; i++)
            ans+=sum[i]+add[i]*(R[i]-L[i]+1);
        for(int i=l; i<=R[p]; i++)
            ans+=data[i];
        ans+=add[p]*(R[p]-l+1);
        for(int i=L[q]; i<=r; i++)
            ans+=data[i];
        ans+=add[q]*(r-L[q]+1);
    }
    return ans;
}
int main() {
    scanf("%lld%lld",&N,&Q);
    for(int i=1; i<=N; i++)
        scanf("%lld",&data[i]);
    ll t=sqrt(N);
    ll num=N/t;
    if(N%t)
        num++;
    for(int i=1; i<=num; i++) {
        L[i]=(i-1)*t+1;
        R[i]=i*t;
    }
    for(int i=1; i<=num; i++)
        for(int j=L[i]; j<=R[i]; j++) {
            pos[j]=i;
            sum[i]+=data[j];
        }
    while(Q--) {
        char ch;
        ll a,b,c;
        cin >>ch;
        switch(ch) {
        case 'C':
            scanf("%lld%lld%lld",&a,&b,&c);
            Update(a,b,c);
            break;
        case 'Q':
            scanf("%lld%lld",&a,&b);
            printf("%lld\n",Query(a,b));
            break;
        }
    }
    return 0;
}

POJ1019

题目大意：有这样一个序列112123123412345…1234567891012345…，该序列由无数个数字组组成，每个数字组有k个数字(k各不相同且从小到大)，组内有1~k这k个数字，现在给出一个位置i，输出序列第i位数字是多少(从1开始算)

思路：把每个组看成一个分块，每个组长度为a[i]，当组内都是个位数时，当前组长度为前一组+1,当组内都为两位数时，当前组长度为前一组+2，以此类推。计算每一块长度a[i]和前i块总长度sum[i]，定位到第i块，在块内查找第pos位所在的数k，数k可能为多位数，第pos为 k / ( i n t ) p o w ( 10.0 , l e n − p o s ) % 10 k/(int)pow(10.0,len-pos)\%10 k/(int)pow(10.0,len−pos)%10，其余详见代码

代码

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
typedef long long ll;
ll a[121212],sum[121212];//空间需足够大
int t;
int main() {
    for(int i=1; i<121212; i++) {
        a[i]=a[i-1]+(int)log10(double(i))+1;//log10获得是几位十进制
        sum[i]=sum[i-1]+a[i];
    }
    scanf("%d",&t);
    while(t--) {
        int n,i=0;
        scanf("%d",&n);//n以位单位
        while(sum[i]<n)//确定n在第i块
            i++;
        int pos=n-sum[i-1],len=0,k=0;//确定n在第i块的第pos个位置
        while(len<pos)
            len+=(int)log10((double)(++k))+1;//初始值为1，len获得了前k个数字的总长度,k为第几个数字
        printf("%d\n",k/(int)pow(10.0,len-pos)%10);
        //此时的k是pos对应所在的数字，len是包括了k这个数字的总长度，len-pos为第k个数字在pos之后的位数，需要去掉，%10将所得数取个位得到结果
    }
    return 0;
}

POJ4417

题目大意：查询给定区间内小于等于特定值的数量

思路：分块，并对每一块非递减排序，在辅助数组上排序，查询给定区间，若属于同一块，直接暴力统计，若不属于同一块，在辅助数组上用upper_bound函数统计，首尾端暴力

代码

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
int T,data[121212],temp[121212],L[121212],R[121212],n,m,belong[121212];
void Build() {
    int t=sqrt(n);//每个块的大小
    int num=n/t;
    if(n%num)
        num++;//有多少块
    for(int i=1; i<=num; i++) {//画出每个块左右边界
        L[i]=(i-1)*t+1;
        R[i]=i*t;
    }
    R[num]=n;//最后一个边界特殊对待
    for(int i=1; i<=n; i++)//归属每个元素
        belong[i]=(i-1)/t+1;
    for(int i=1; i<=num; i++)
        sort(temp+L[i],temp+R[i]+1);//对临时块排序
}
int Query(int l,int r,int t) {
    int ans=0;
    if(belong[l]==belong[r])//如果是同一个块，直接暴力
        for(int i=l; i<=r; i++) {
            if(data[i]<=t)
                ans++;
        } else {
        for(int i=l; i<=R[belong[l]]; i++)//左端
            if(data[i]<=t)
                ans++;
        for(int i=belong[l]+1; i<belong[r]; i++)//中间
            ans+=upper_bound(temp+L[i],temp+R[i]+1,t)-temp-L[i];
        for(int i=L[belong[r]]; i<=r; i++)//右端
            if(data[i]<=t)
                ans++;
    }
    return ans;
}
int main() {
    scanf("%d",&T);
    for(int i=1; i<=T; i++) {
        scanf("%d%d",&n,&m);
        for(int i=0; i<n; i++) {
            scanf("%d",&data[i]);
            temp[i]=data[i];
        }
        Build();
        printf("Case %d:\n",i);
        while(m--) {
            int l,r,H;
            scanf("%d%d%d",&l,&r,&H);
            printf("%d\n",Query(l,r,H));
        }
        memset(temp,0,sizeof(temp));
    }
    return 0;
}

HDU5057

题目大意：对序列两种操作，将位置x上的值变为y(从1算)和统计区间[l,r]内元素第D位是P的元素的个数(二进制)

思路：分块，block[i][j][k]表示第i块中第j位是k的元素，查询，若区间为同一块，暴力累加，多个块，累加完全覆盖区域的block，暴力首尾，更新，需要去掉a[x]每一位上的元素，把a[x]换成y，然后以y为基准来增加，详见代码

代码

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
int block[400][12][12],a[1212121],belong[1212121],L[1212121],R[1212121],n,m,T;
int ten[11]= {0,1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};
void Build() {
    int t=sqrt(n);
    int num=n/t;
    if(n%t)
        num++;
    for(int i=1; i<=num; i++) {
        L[i]=(i-1)*t+1;
        R[i]=i*t;
    }
    R[num]=n;//划定边界
    for(int i=1; i<=n; i++)//确定归属
        belong[i]=(i-1)/t+1;
    for(int i=1; i<=n; i++) {
        int temp=a[i];
        for(int j=1; j<=10; j++) {
            block[belong[i]][j][temp%10]++;//统计第i个块中第j位01对应元素个数
            temp/=10;
        }
    }
}
int Query(int l,int r,int d,int p) {
    int ans=0;
    if(belong[l]==belong[r]) {//范围为一个块
        for(int i=l; i<=r; i++)
            if((a[i]/ten[d])%10==p)
                ans++;
    } else {
        for(int i=l; i<=R[belong[l]]; i++)//左端
            if((a[i]/ten[d])%10==p)
                ans++;
        for(int i=L[belong[r]]; i<=r; i++)//中端
            if((a[i]/ten[d])%10==p)
                ans++;
        for(int i=belong[l]+1; i<belong[r]; i++)//右端
            ans+=block[i][d][p];
    }
    return ans;
}
void Update(int x,int y) {
    for(int i=1; i<=10; i++) {
        block[belong[x]][i][a[x]%10]--;
        a[x]/=10;
    }
    a[x]=y;
    for(int i=1; i<=10; i++) {
        block[belong[x]][i][y%10]++;
        y/=10;
    }
}
int main() {
    scanf("%d",&T);
    while(T--) {
        scanf("%d%d",&n,&m);
        for(int i=1; i<=n; i++)
            scanf("%d",&a[i]);
        Build();
        while(m--) {
            char ch;
            int L,R,D,P;
            cin >>ch;
            if(ch=='S') {
                scanf("%d%d",&L,&R);
                Update(L,R);
            } else if(ch=='Q') {
                scanf("%d%d%d%d",&L,&R,&D,&P);
                printf("%d\n",Query(L,R,D,P));
            }
        }
        memset(belong,0,sizeof(belong));
        memset(L,0,sizeof(L));
        memset(R,0,sizeof(R));
        memset(block,0,sizeof(block));
    }
    return 0;
}

总结

分块算法虽然时间复杂度还不够优秀，但是其通用性和模板的可变化是很大的优点，而且较容易理解，模板也较容易

C_eeking
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分块算法总结&专题训练
Plozia 的小窝
12-12 413
1.概述 分块，被称为优雅的暴力，实质上分块就是一种暴力算法。但是分块因其优美性与可扩展性，使得很多题目往往用分块做更简洁。而分块的最重要的一句话就是：大块维护，小块朴素。 分块被称为暴力是因为其时间复杂度是 O(nn)O(n\sqrt n)O(nn​) ，如果卡常不当就可能会被卡掉，或者直接卡成 O(n2)O(n^2)O(n2)。 莫队算法也是基于分块的（有兴趣了解莫队的可以看一看我的 这篇博文），并且很多用线段树、树套树等算法做的题目往往用分块可以吊打 std。因此，分块还是很重要的一种算法。 接下来通
51单片机tention-model-for-network-idsk开发笔记
最新发布
06-24
因此，可能需要采用模型压缩、分块加载或在线训练的方式。 3. 编程语言选择：51单片机通常使用汇编语言或C语言编程，因此需要将深度学习模型转换为这些语言可执行的形式，如使用MicroPython或TinyML框架。 4. 数据...
分块练习
slongle的专栏
04-02 720
[CodeVS1080]题目大意支持1.单点修改2.区间和查询题解分块维护区间和 CODE[BZOJ1901] Zju2112 Dynamic Rankings题目大意支持1.单点修改2.区间第k大查询题解分块,块内维护递增序列 修改时,二分找到要修改的在块内的位置,再对块重建快排,O(Mn−−√logn−−√)O(M\sqrt{n}log\sqrt{n}) 查询时,二分答案,查询区间内<=a
分块练习题
cheng__yu_的博客
08-21 262
243. 一个简单的整数问题2 链接：https://www.acwing.com/problem/content/244/ 题意：维护区间修改，维护区间查询 思路：分块维护 #include <bits/stdc++.h> #define ll long long using namespace std; const int maxn=1e5+10; int n,m,B,a[maxn]; ll res[maxn],base[maxn]; ll query(int l,int r) {
数列分块入门1 – 9 by hzwer
剑锋OI SharpSwordOI
04-11 1020
数列分块入门1 – 9 by hzwer 本文非原创，原创地址http://hzwer.com/8053.html - 可能涉及的几个词语解释： 区间：数列中连续一段的元素 区间操作：将某个区间[a,b]的所有元素进行某种改动的操作 块：我们将数列划分成若干个不相交的区间，每个区间称为一个块 整块：在一个区间操作时，完整包含于区间的块 不完整的块：在一个区间操作时，只有部分包含于区间的块...
分块算法介绍(分块入门练习-1)
Hardict的算法日记
09-06 1711
前言 之前只了解分块,但没有深入学习.但之前集训时遇到http://codeforces.com/gym/100960/problem/G,当时现场树状数组没有调出来,赛后写出后上网搜其他方法,发现了一个奇妙的分块方法,便决定抽空深入学习一下这种优化的暴力——分块.  关键名词: 区间：一段连续子序列 区间操作：对某个区间进行同类型相同规模的操作 块：将一个数列划分为连续的块分块算法一般...
2018_2019学年高考英语一轮复习Unit9Wheels高考试卷分块专练北师大版必修3
09-09
本资料特别针对Unit 9 "Wheels"进行高考试卷的专项训练，强调通过分块练习来提高不同题型的解题速度和准确率。 2. 阅读理解训练：阅读理解是高考英语的重要组成部分，本资料设置了限时35分钟的阅读理解提速练，旨在...
新东方8天攻克8000单词魔鬼训练营
03-28
2. **分块记忆**：将大量单词分成小组，每次专注于一小部分，避免一次性记忆过多导致的信息过载。 3. **故事法**：用故事串联起单词，使记忆过程更具趣味性。 4. **间隔重复**：利用艾宾浩斯遗忘曲线，定期复习单词...
北京大学-曹建-人工智能实践TensorFlow课件和代码）
10-16
- 助教的Tensorflow笔记系列：这些PDF文档可能是课程的辅助材料，详细解释了TensorFlow的基本概念、模型构建、训练过程以及可能遇到的问题和解决方案。例如，第一讲可能涵盖了TensorFlow的入门介绍，后续的笔记可能...
vidAIo:基于NLPCV的视频搜索引擎
06-26
在 CV 方面，有一个在 Cifar10 数据集上训练的神经网络（建立在 Torch7 上），达到 57% 的准确率（在笔记本电脑上训练大约一个小时还不错），还有一个面部识别系统（PCA+SVM，建立在在 scikit-learn 上）。...
C算法编程题（四）上三角
weixin_33758863的博客
11-05 344
前言 　　上一篇《C算法编程题（三）画表格》 　　上几篇说的都是根据要求输出一些字符、图案等，今天就再说一个“上三角”，有点类似于第二篇说的正螺旋，输出的字符少了，但是逻辑稍微复杂了点。 程序描述 　　方阵的主对角线之上称为“上三角”。    请你设计一个用于填充n阶方阵的上三角区域的程序。填充的规则是：使用1，2，3….的自然数列，从左上角开始，按照顺时针方向螺旋填充。    例如：当...
【算法题】求第N位数字，数列如下112123123412345123456
Learning by doing
05-02 4337
【算法题】自增自然数列组，求第N位的数字，数列如下112123123412345123456首先，鄙视下出这个题目的人，人为增加难度，无聊。这个题目如果之前没见过，想短时间写出来还是需要一定的脑力的，一步一步抽丝剥茧吧：①先把该数列看成如下形式：11212312345123456……这样我们可以将每个子串单独分析，可以看出来第i个子串比第i-1个子串多一个数i，数i的长度为log10(i)+1，也...
2020.02.01【NOIP普及组】模拟赛C组
ha
02-02 610
题目编号 标题 0 怪兽 1 白板 2 序列 3 游戏 T1 题目描述 PYWBKTDA最近正在打怪兽,一个斯拉夫神话中的凶猛怪兽,一个有着多个头的巨大龙状爬行 动物。 开始的时候,怪兽有X个头,你有n种打击方式。如果你选择第i种打击方式,这个神奇的怪兽会减 少min(d i ,cur)个头。这里cur表示当前怪兽拥有的头的数量。但是如果怪兽被打击以后还至少留下 了一个头,那么它就会再长出h...
经典算法之数串
yingmuliuchuan的博客
12-23 1296
设有n个正整数，将他们连接成一排，组成一个最大的多位整数。如:n=3时，3个整数13,312,343,连成的最大整数为34331213。 输入：正整数个数，正整数数值 输出：拼接的最大值（或最小值） 该问题仔细分析一下其实算是一种比较高端的排序问题，但是不是普通的数值排序，而是将输入的值转换为字符串进行字符串排序，然后拼接。 加入A和B是其中的两个数值，重点是需要比较“A”+“B” 与 “
Problem 34—Digit factorials
Hello Java
04-22 471
题目描述如下： 145 is a curious number, as 1! + 4! + 5! = 1 + 24 + 120 = 145. Find the sum of all numbers which are equal to the sum of the factorial of their digits. Note: as 1! = 1 and 2! = 2 are no
POJ 1019 许久之前，觉得这真是一道神题呢。。 递推+二分
用心一也
02-24 587
11212312341234512345612345671234567812345678912345678910123456789101112345678910 给出一串有以上规律的数字，找出第 n 个位置上的数字是几。 我们把这串字符串分一下 dp[i] 代表从 1 开始 结尾为 i 的子串的长度 sum[i] 代表从 1 开始到 i 子串长度的总和。 这样，我们首先确定这是到哪一个子
WEEK9 周记 限时赛——模拟题_咕咕东的奇妙序列
wcxiaobaiaa的博客
04-29 215
WEEK9 周记 限时赛——模拟题_咕咕东的奇妙序列 一、题意 1.简述 一个奇怪的无限序列：112123123412345 …这个序列由连续正整数组成的若干部分构成，其 中第一部分包含1至1之间的所有数字，第二部分包含1至2之间的所有数字，第三部分包含1至3之间的所 有数字，第i部分总是包含1至i之间的所有数字。所以，这个序列的前56项会是 112123123412345123456123456...
CSPM3
pgsld2333的博客
05-12 254
T1 瑞神的序列 题目描述 瑞神的数学一向是最好的，连强大的咕咕东都要拜倒在瑞神的数学水平之下，虽然咕咕东很苦 恼，但是咕咕东拿瑞神一点办法都没有。 5.1期间大家都出去玩了，只有瑞神还在孜孜不倦的学习，瑞神想到了一个序列，这个序列长度为 ，也就是一共有 个数，瑞神给自己出了一个问题：数列有几段？ 段的定义是连续的相同的最长整数序列。 输入描述 输入第一行一个整数n，表示数的个数 接下来一行n个空格隔开的整数，表示不同的数字。 输出描述 输出一行，这个序列有多少段。 数据规模 数据点 数据范围
咕咕东的奇妙序列【二分】【数学规律】【等差数列】
YingMila的博客
04-17 349
题目描述 咕咕东 正在上可怕的复变函数，但对于稳拿A Plus的 咕咕东 来说，她早已不再听课，此时她在睡梦中 突然想到了一个奇怪的无限序列：112123123412345 …这个序列由连续正整数组成的若干部分构成，其 中第一部分包含1至1之间的所有数字，第二部分包含1至2之间的所有数字，第三部分包含1至3之间的所 有数字，第i部分总是包含1至i之间的所有数字。所以，这个序列的前56项会是 112...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值