数列分块九讲板子（封装）

已于 2022-10-28 09:06:36 修改
阅读量137 收藏
点赞数 1
分类专栏： acm暑假训练 数据结构 文章标签： 数据结构 c++ 算法
于 2022-07-11 16:26:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51028279/article/details/125487729
版权

第一讲：区间加减，单点查询

复杂度：O(n\sqrt n)

#include<bits/stdc++.h>
#define ll long long
#define int long long
#define endl "\n"
#define P pair<int,int>
#define f first
#define s second
using namespace std;
typedef unsigned long long ull;
const int maxn=200010;
const int inf=0x3f3f3f3f;
const int mod=998244353;
int t;
int n,m,k;
struct fenkuai{
    const int n1,blo;
    vector<int> a,block,tag;
    vector<vector<int> > ve;
    fenkuai(int nn,vector<int> &a2,int n2):n1(nn),blo(n2),a(nn+5),block(nn+5),tag(nn+5,0),ve(n2+5)
    {
        for(int i=1;i<=nn;i++)
            a[i]=a2[i];
        for(int i=1;i<=nn;i++)
        {
            block[i]=(i-1)/blo+1;
            ve[block[i]].push_back(a[i]);
        }
    }
    void add(int l,int r,int x)
    {
        for(int i=l;i<=min(block[l]*blo,r);i++)
            a[i]+=x;
        if(block[l]!=block[r])
        {
            for(int i=(block[r]-1)*blo+1;i<=r;i++)
                a[i]+=x;
        }
        for(int i=block[l]+1;i<=block[r]-1;i++)
            tag[i]+=x;
    }
    int query(int x)
    {
        return a[x]+tag[block[x]];
    }
};
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    cin>>n;
    vector<int> a(n+5);
    for(int i=1;i<=n;i++)
        cin>>a[i];
    fenkuai fk1(n,a,sqrt(n));
    while(n--)
    {
        int nb,l,r,c;
        l++;
        r++;
        cin>>nb>>l>>r>>c;
        if(nb==0)
            fk1.add(l,r,c);
        else
            cout<<fk1.query(r)<<endl;
    }
    return 0;
}

第二讲：区间加减，查询区间内小于x的数的个数 

复杂度：O(n\sqrt n log\sqrt n+nlogn)

#include<bits/stdc++.h>
#define ll long long
#define int long long
#define endl "\n"
#define P pair<int,int>
#define f first
#define s second
using namespace std;
typedef unsigned long long ull;
const int maxn=200010;
const int inf=0x3f3f3f3f;
const int mod=998244353;
int t;
int n,m,k;
struct fenkuai{
    const int n1,blo;
    vector<int> a,block,tag;
    vector<vector<int> > ve;
    fenkuai(int nn,vector<int> &a2,int n2):n1(nn),blo(n2),a(nn+5),block(nn+5),tag(nn+5),ve(n2+5)
    {
        for(int i=1;i<=nn;i++)
            a[i]=a2[i];
        for(int i=1;i<=nn;i++)
        {
            block[i]=(i-1)/blo+1;
            ve[block[i]].push_back(a[i]);
        }
        for(int i=1;i<=block[nn];i++)
            sort(ve[i].begin(),ve[i].end());
    }
    void reset(int x)
    {
        ve[x].clear();
        for(int i=(x-1)*blo+1;i<=min(x*blo,n1);i++)
            ve[x].push_back(a[i]);
        sort(ve[x].begin(),ve[x].end());
    }
    void add(int l,int r,int x)
    {
        for(int i=l;i<=min(block[l]*blo,r);i++)
            a[i]+=x;
        reset(block[l]);
        if(block[l]!=block[r])
        {
            for(int i=(block[r]-1)*blo+1;i<=r;i++)
                a[i]+=x;
            reset(block[r]);
        }
        for(int i=block[l]+1;i<=block[r]-1;i++)
            tag[i]+=x;
    }
    int query(int l,int r,int c)
    {
        int ans=0;
        for(int i=l;i<=min(block[l]*blo,r);i++)
        {
            if(a[i]+tag[block[l]]<c)
                ans++;
        }
        if(block[l]!=block[r])
        {
            for(int i=(block[r]-1)*blo+1;i<=r;i++)
                if(a[i]+tag[block[r]]<c)
                    ans++;
        }
        for(int i=block[l]+1;i<=block[r]-1;i++)
        {
            int x=c-tag[i];
            ans+=lower_bound(ve[i].begin(),ve[i].end(),x)-ve[i].begin();
        }
        return ans;
    }
};
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    cin>>n;k=n;
    vector<int> a(n+5);
    for(int i=1;i<=n;i++)
        cin>>a[i];
    fenkuai fk1(n,a,sqrt(n));
    while(k--)
    {
        int nb,l,r,c;
        cin>>nb>>l>>r>>c;
        if(nb==0)
            fk1.add(l,r,c);
        else
            cout<<fk1.query(l,r,c*c)<<endl;
    }
    return 0;
}

第三讲：区间加减 ，找x的前驱（区间内比x小的最大元素）

 复杂度：O(n\sqrt n log\sqrt n+nlogn)

#include<bits/stdc++.h>
#define ll long long
#define int long long
#define endl "\n"
#define P pair<int,int>
#define f first
#define s second
using namespace std;
typedef unsigned long long ull;
const int maxn=200010;
const int inf=0x3f3f3f3f;
const int mod=998244353;
int t;
int n,m,k;
struct fenkuai{
    const int n1,blo;
    vector<int> a,block,tag;
    vector<vector<int> > ve;
    fenkuai(int nn,vector<int> &a2,int n2):n1(nn),blo(n2),a(nn+5),block(nn+5),tag(nn+5),ve(n2+5)
    {
        for(int i=1;i<=nn;i++)
            a[i]=a2[i];
        for(int i=1;i<=nn;i++)
        {
            block[i]=(i-1)/blo+1;
            ve[block[i]].push_back(a[i]);
        }
        for(int i=1;i<=block[nn];i++)
            sort(ve[i].begin(),ve[i].end());
    }
    void reset(int x)
    {
        ve[x].clear();
        for(int i=(x-1)*blo+1;i<=min(x*blo,n1);i++)
            ve[x].push_back(a[i]);
        sort(ve[x].begin(),ve[x].end());
    }
    void add(int l,int r,int x)
    {
        for(int i=l;i<=min(block[l]*blo,r);i++)
            a[i]+=x;
        reset(block[l]);
        if(block[l]!=block[r])
        {
            for(int i=(block[r]-1)*blo+1;i<=r;i++)
                a[i]+=x;
            reset(block[r]);
        }
        for(int i=block[l]+1;i<=block[r]-1;i++)
            tag[i]+=x;
    }
    int query(int l,int r,int c)
    {
        int ans=-inf*inf;
        for(int i=l;i<=min(block[l]*blo,r);i++)
        {
            if(a[i]+tag[block[l]]<c)
                ans=max(ans,a[i]+tag[block[l]]);
        }
        if(block[l]!=block[r])
        {
            for(int i=(block[r]-1)*blo+1;i<=r;i++)
                if(a[i]+tag[block[r]]<c)
                    ans=max(ans,a[i]+tag[block[r]]);
        }
        for(int i=block[l]+1;i<=block[r]-1;i++)
        {
            int x=c-tag[i];
            auto it=lower_bound(ve[i].begin(),ve[i].end(),x);//找到块中第一个大于等于x的值
            if(it!=ve[i].begin())
            {
                it--;
                ans=max(ans,*it+tag[i]);//这里要加上tag[i]
            }
        }
        if(ans!=-inf*inf)
            return ans;
        else
            return -1;
    }
};
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    cin>>n;k=n;
    vector<int> a(n+5);
    for(int i=1;i<=n;i++)
        cin>>a[i];
    fenkuai fk1(n,a,sqrt(n));
    while(k--)
    {
        int nb,l,r,c;
        cin>>nb>>l>>r>>c;
        if(nb==0)
            fk1.add(l,r,c);
        else
            cout<<fk1.query(l,r,c)<<endl;
    }
    return 0;
}

第四讲：区间加减，区间求和并模(c+1)

 复杂度：O(n\sqrt n)

#include<bits/stdc++.h>
#define ll long long
#define int long long
#define endl "\n"
#define P pair<int,int>
#define f first
#define s second
using namespace std;
typedef unsigned long long ull;
const int maxn=200010;
const int inf=0x3f3f3f3f;
const int mod=998244353;
int t;
int n,m,k;
struct fenkuai{
    const int n1,blo;
    vector<int> a,block,tag,sum;
    vector<vector<int> > ve;
    fenkuai(int nn,vector<int> &a2,int n2):n1(nn),blo(n2),a(nn+5),block(nn+5),tag(nn+5,0),sum(nn+5,0),ve(n2+5)
    {
        for(int i=1;i<=nn;i++)
            a[i]=a2[i];
        for(int i=1;i<=nn;i++)
        {
            block[i]=(i-1)/blo+1;
            sum[block[i]]+=a[i];
        }
    }
    void add(int l,int r,int x)
    {
        for(int i=l;i<=min(block[l]*blo,r);i++)
        {
            a[i]+=x;
            sum[block[i]]+=x;
        }
        if(block[l]!=block[r])
        {
            for(int i=(block[r]-1)*blo+1;i<=r;i++)
            {
                a[i]+=x;
                sum[block[i]]+=x;
            }
        }
        for(int i=block[l]+1;i<=block[r]-1;i++)
        {
            tag[i]+=x;
            sum[i]+=x*blo;
        }
    }
    int query(int l,int r,int c)
    {
        int ans=0;
        for(int i=l;i<=min(block[l]*blo,r);i++)
            ans=(ans+a[i]+tag[block[i]])%c;
        if(block[l]!=block[r])
        {
            for(int i=(block[r]-1)*blo+1;i<=r;i++)
                ans=(ans+a[i]+tag[block[i]])%c;
        }
        for(int i=block[l]+1;i<=block[r]-1;i++)
            ans=(ans+sum[i])%c;
        return ((ans%c)+c)%c;
    }
};
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    cin>>n;
    vector<int> a(n+5);
    for(int i=1;i<=n;i++)
        cin>>a[i];
    fenkuai fk1(n,a,sqrt(n));
    while(n--)
    {
        int nb,l,r,c;
        cin>>nb>>l>>r>>c;
        if(nb==0)
            fk1.add(l,r,c);
        else
            cout<<fk1.query(l,r,c+1)<<endl;
    }
    return 0;
}

第五讲: 区间开方，区间求和

复杂度：（略）

#include<bits/stdc++.h>
#define ll long long
#define int long long
#define endl "\n"
#define P pair<int,int>
#define f first
#define s second
using namespace std;
typedef unsigned long long ull;
const int maxn=200010;
const int inf=0x3f3f3f3f;
const int mod=998244353;
int t;
int n,m,k;
struct fenkuai{
    const int n1,blo;
    vector<int> a,block,flag,sum;
    fenkuai(int nn,vector<int> &a2,int n2):n1(nn),blo(n2),a(nn+5),block(nn+5),flag(nn+5,0),sum(nn+5,0)
    {
        for(int i=1;i<=nn;i++)
            a[i]=a2[i];
        for(int i=1;i<=nn;i++)
        {
            block[i]=(i-1)/blo+1;
            sum[block[i]]+=a[i];
        }
    }
    void slove_sqrt(int x)
    {
        if(flag[x])
            return;
        flag[x]=1;
        sum[x]=0;
        for(int i=(x-1)*blo+1;i<=x*blo;i++)
        {
            a[i]=sqrt(a[i]);
            sum[x]+=a[i];
            if(a[i]>1)
                flag[x]=0;
        }
    }
    void add(int l,int r,int x)
    {
        for(int i=l;i<=min(block[l]*blo,r);i++)
        {
            sum[block[i]]-=a[i];
            a[i]=sqrt(a[i]);
            sum[block[i]]+=a[i];
        }
        if(block[l]!=block[r])
        {
            for(int i=(block[r]-1)*blo+1;i<=r;i++)
            {
                sum[block[i]]-=a[i];
                a[i]=sqrt(a[i]);
                sum[block[i]]+=a[i];
            }
        }
        for(int i=block[l]+1;i<=block[r]-1;i++)
            slove_sqrt(i);
    }
    int query(int l,int r)
    {
        int ans=0;
        for(int i=l;i<=min(block[l]*blo,r);i++)
            ans+=a[i];
        if(block[l]!=block[r])
        {
            for(int i=(block[r]-1)*blo+1;i<=r;i++)
                ans+=a[i];
        }
        for(int i=block[l]+1;i<=block[r]-1;i++)
            ans+=sum[i];
        return ans;
    }
};
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    cin>>n;
    vector<int> a(n+5);
    for(int i=1;i<=n;i++)
        cin>>a[i];
    fenkuai fk1(n,a,sqrt(n));
    while(n--)
    {
        int nb,l,r,c;
        cin>>nb>>l>>r>>c;
        if(nb==0)
            fk1.add(l,r,c);
        else
            cout<<fk1.query(l,r)<<endl;
    }
    return 0;
}

第六讲：单点插入，单点查询

复杂度：（略）

/*
 author:wuzx
 */

#include<bits/stdc++.h>
#define ll long long
#define int long long
#define endl "\n"
#define P pair<int,int>
#define f first
#define s second
using namespace std;
typedef unsigned long long ull;
const int maxn=200010;
const int inf=0x3f3f3f3f;
const int mod=998244353;
int t;
int n,m,k;
struct fenkuai{
    const int n1,blo;
    int mm;
    vector<int> a,st;
    vector<vector<int> > ve;
    fenkuai(int nn,vector<int> &a2,int n2):n1(nn),blo(n2),a(nn+5),st(nn*2+5),ve(n2*2+5)
    {
        for(int i=1;i<=nn;i++)
            a[i]=a2[i];
        for(int i=1;i<=nn;i++)
            ve[(i-1)/blo+1].push_back(a[i]);
        mm=(nn-1)/blo+1;
    }
    pair<int,int> query(int b)
    {
        int x=1;
        while(b>ve[x].size())
        {
            b-=ve[x].size();
            x++;
        }
        return make_pair(x,b-1);
    }
    void rebuild()
    {
        int top=0;
        for(int i=1;i<=mm;i++)
        {
            for(vector<int>::iterator j=ve[i].begin();j!=ve[i].end();j++)
                st[++top]=*j;
            ve[i].clear();
        }
        int blo2=sqrt(top);
        for(int i=1;i<=top;i++)
            ve[(i-1)/blo2+1].push_back(st[i]);
        m=(top-1)/blo2+1;
    }
    void insert(int idx,int x)
    {
        pair<int,int> tt=query(idx);
        ve[tt.f].insert(ve[tt.f].begin()+tt.s,x);
        if(ve[tt.f].size()>20*blo)
            rebuild();
    }
    int getnum(int idx)
    {
        pair<int,int> tt=query(idx);
        return ve[tt.f][tt.s];
    }
};
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    cin>>n;k=n;
    vector<int> a(n+5);
    for(int i=1;i<=n;i++)
        cin>>a[i];
    fenkuai fk1(n,a,sqrt(n));
    while(k--)
    {
        int nb,l,r,c;
        cin>>nb>>l>>r>>c;
        if(nb==0)
            fk1.insert(l,r);
        else
            cout<<fk1.getnum(r)<<endl;
    }
    return 0;
}

8aceMaker
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法-数列分块入门 8（LibreOj-6284）.rar
09-16
算法-数列分块入门 8（LibreOj-6284）.rar
数列分块入门2--LOJ（区间小于x的个数）
孤风的博客
09-03 654
题目链接https://loj.ac/problem/6278 内存限制：256 MiB时间限制：500 ms 题目描述 给出一个长为n 的数列，以及 n个操作，操作涉及区间加法，询问区间内小于某个值 x 的元素个数。 输入格式 第一行输入一个数字。 第二行输入 n 个数字，第 i 个数字为 ai，以空格隔开。 接下来输入n 行询问，每行输入四个数字opt,l,r,c以空格...
分块学习笔记
Welcome to yjjr's blog!
02-01 562
根号平衡 根号类算法的前置技能大多是根号平衡 有x次操作，单次复杂度为O(a) 有y=kx次查询，单次复杂度为O(b) 在满足一定条件的题里面 可以通过提高其中一边的复杂度，降低另一边的复杂度来达到更好的效果 这时有xa=kxb ==> 复杂度由ax+bkx=2x 根号分类 静态分块 动态分块 静态分块指的是放一些关键点，预处理关键点到关键点的信息来加速查询的，不能支持修改
分块九讲
weixin_30614109的博客
08-08 189
分块九讲 原作者：Hzwer 一 二 三 四 五 六 转载于:https://www.cnblogs.com/BigYellowDog/p/11323536.html
线性结构 —— 分块算法 —— 分块九讲
Alex_McAvoy的博客
08-02 1231
模型1：区间加法，单点询问 问题：给出一个长为 n 的数列，以及 n 个操作，操作涉及区间加法，单点查值。 对每个块设置一个加法标记，记录这个块中元素一共加了多少，每次操作对整块直接 O(1) 标记，而不完整块元素较少，暴力修改元素的值即可，每次询问时返回元素的值加上其所在块的加法标记。 模型2：区间加法，询问区间内小于某个值 x 的元素个数 问题：给出一个长为 n 的数列，以及 n 个操...
数列分块入门9(区间众数)
Exception
01-13 511
原题：https://loj.ac/problem/6285 题解:基本题意求[l,r]的最小众数，对于集合 A,B 显然 mode(A and B)属于 mode(A) and B。这样就可以分块，预处理f[i][j]表示i-j的众数。每次查询时暴力查询头尾两块的数和中间块的众数就可以，关于查询x在[l,r]出现了几次，用动态数组存放x的下标，二分查找就好了。可以先给a数组离散化。这道题块的大...
算法-数列分块入门 7（LibreOj-6283）.rar
09-16
算法-数列分块入门 7（LibreOj-6283）.rar
算法-数列分块入门 9（LibreOj-6285）.rar
09-16
算法-数列分块入门 9（LibreOj-6285）.rar
算法-数列分块入门 6（LibreOj-6282）.rar
09-16
算法-数列分块入门 6（LibreOj-6282）.rar
算法-数列分块入门 5（LibreOj-6281）.rar
09-16
算法-数列分块入门 5（LibreOj-6281）.rar
9.数列分块入门 9
HeartFireY的博客
09-22 370
???? | Powered By HeartFireY | 分块例题 #6285. 数列分块入门 9 - 题目 - LibreOJ (loj.ac) WTF卡常？？？ 首先DPDPDP预处理出完整的块iii到完整的块jjj之间的最小众数dp[i][j]dp[i][j]dp[i][j]。 用一个vectorvectorvector邻接表保存相同的下标， 然后就根据upper_boundupper\_boundupper_bound和lower_boundlower\_boundlower_bound求出完整
分块9讲：
吾之奉先的博客
07-26 296
三、 求区间x前驱； 1、vector版本： #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;cmath&gt; #include &lt;vector&gt; #include &lt;cstdio&gt; #include &lt;string&gt; using namespace std; type...
分块算法讲解
热门推荐
XianHaoMing的博客
08-13 1万+
分块先简单介绍一下分块算法。 分块算法是一种很常见的根号算法，一般它的时间复杂度会带根号。 分块和线段树的区别在于，分块算法可以维护一些线段树维护不了的东西，例如单调队列等，线段树能维护的东西必须能够进行信息合并，而分块则不需要。不过，它们也有共同点，分块和线段树一样，分块需要支持类似标记合并的东西。 简单来说，分块算法就是优化过后的暴力。现在讲一下这种算法的实现。 这种算法会将序列（序列
分块大法好：数列分块入门1~9
kkkGIGi_qtt
03-28 4189
艰苦地刷了4天半的分块 深感分块是一个非常巧（暴）妙（力） 的算法 如果有觉得hzwer的代码太奇妙（看不懂）的推荐一下机房大佬的通俗易懂的代码： http://www.cnblogs.com/CHerish_OI/category/1176577.html（此处手动艾特cherish_oi同学） http://hzwer.com/8053.html loj#6277. 数列分块入门...
分块九题 --- 1
sdfzsyq的博客
06-14 170
题目 题解 本蒟蒻要开始学分块了，区间查询神器，区间修改单点查询。 代码 #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; const int MAXN = 50005; const int N = 305; inline int rd(){ int x=0,f=1;char ch=getchar(); wh...
线性结构 —— 分块算法
Alex_McAvoy的博客
07-31 487
【概述】 所谓分块，即对于一个长度为 n 的序列，设块的大小为 S，从序列的第一个元素起，每 S 个元素被分成一块，若剩余的元素不足 S 个，令他们组成一块。经过分块后的数组，称为块状数组，在块状数组的基础上加以扩展，即可得到块状链表。 在一个区间操作时，完整包含于区间的块称为整块，只有部分包含于区间的块，称为不完整的块，不完整的块实质上行即为区间左右端点所在的两个块。 在许多区间问题中，使...
[LOJ] 分块九题 7
weixin_34409741的博客
04-13 72
区间加法，区间乘法，单点查询。 洛谷线段树2 屡清加法乘法的关系，定义答案为 a*mut+add 对于整块： 新的乘w，mut和add都要乘w 新的加w，add加w //Stay foolish,stay hungry,stay young,stay simple #include<iostream> #include<cmath&g...
数列分块入门 9 / 蒲公英
weixin_33797791的博客
05-19 129
区间众数 这题是强制在线的，所以只有分块了，不然的话还可以莫队。。 预处理出每块之间的众数以及每个数出现的位置，查询的时候块内直接查询，不足整块的直接二分l和r，相减就是一个数出现的次数了，然后更新答案即可。 #include <bits/stdc++.h> #define INF 0x3f3f3f3f #define full(a, b) memset(a, b, sizeof a)...
2.函数应用-斐波那契数列 将上述斐波那契数列封装成一个函数，给函数一个参数输出斐波那契数 列 示例：[0, 1, 1, 2, 3, 5, 8, 13, 21,
最新发布
04-18
下面是封装斐波那契数列的函数代码： ``` def fibonacci(n): if n return [] elif n == 1: return [0] elif n == 2: return [0, 1] else: fib_list = [0, 1] for i in range(2, n): fib_list.append(fib...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值