分块

                             分块

分块，顾名思义，就是将序列分成一小块一小块的来处理和维护。

我们把一段当成一个整体，只记录整体有关的信息，这就是分块。

首先，我们考虑一道题。

1.区间修改，查询区间中一段区间有多少数 < k;

  一种朴素算法就是，暴力从区间 L 到 R 扫过去，每遇到小于k的位置加1

没错，是不是这种方法很傻。但分块就是从这里优化过来的。

假设，我们有一个长度为 n 的序列，然后我们把他切成 sqrt（n）块，把每一块中的东西当成一个整体。（至于为什么块的大小是sqrt（n），自己可以百度一下QAQ）

几个术语：      完整块  被操作区间完全覆盖的块

                        不完整块 不完全覆盖的块

然后我们考虑怎么得出答案

1.    首先我们要预处理每个点在哪个块，以及每个块的左右端点。
2.    然后， 对于不完整的块，我们可以考虑直接暴力修改，因为元素比较少。
3.   那么， 对于完整的块，我们就可以考虑打上lazy标记。

总而言之，分块就是将小块暴力，大块处理的一种方法。

然后这就可以用分块——这种看似高大上的方法做完。。。。。。比之前傻傻的暴力是不是好了很多。

下面就是预处理代码

 

for(int i = 1; i <= n; i++){
    scanf("%d",&a[i]);
    pos[i] = (i-1)/len +1;//每个点所在的块
    L[pos[i]] = 2333333;
}
for(int i = 1; i <= n; i++){
      L[pos[i]] = min(L[pos[i]],i);//每个块的左右端点
      R[pos[i]] = max(R[pos[i]],i);
}

 一个比较重要的问题就是，块的数量不一定是len+1

他正确的是n/len+1

思想讲完了，下面就该看几道题了。

P4145 花神游历各国

题意大概是给出一个长为n的序列，以及n个操作，操作有区间开方和区间求和。

我们会发现开方操作比较难，主要是维护整块时，必须一个个的去修改，那这样岂不是和不同的暴力复杂度不就差不多了吗.

然后我们接着往深里想，不难发现，一个数经过几次开方后，就会变成0或1.

如果每次区间开方只要修改不完整的块，直接暴力修改就可以了。

如果修改一些整块，我们可以只要在每个整块暴力开方后，记录一下元素是否变成了0或1，修改时直接跳过全为0或1的块

就okk了 ，这样每个元素至多开方不超过4次，复杂度刚好可以。

下面是代码；

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
const int N = 1e5+100;
long long n,m,k,l,r;
long long a[N],pos[N],L[N],R[N],sum[N];
bool vis[N];
void check(long long x){//检查每个块是否全为0或1
    if(vis[x]) return;
    vis[x] = 1;
    sum[x] = 0;
    for(int i = L[x]; i <= R[x]; i++){
        a[i] = sqrt(a[i]);
        sum[x] += a[i];
        if(a[i] > 1) vis[x] = 0;
    }
}
void chenge(long long l,long long r){
    int p = pos[l],q = pos[r];
    if(p == q){
        for(int i = l; i <= r; i++){//同一个块直接暴力改
            sum[p] -=a[i];
            a[i] = sqrt(a[i]);
            sum[p] += a[i];
        }
    } 
    else {
        for(int i = p+1; i <= q-1; i++) check(i);
        for(int i = l; i <= R[p]; i++){//左边的散块
            sum[p] -=a[i];
            a[i] = sqrt(a[i]);
            sum[p] += a[i];
        }
        for(int i = L[q]; i <= r; i++){
            sum[q] -= a[i];
            a[i] = sqrt(a[i]);
            sum[q] += a[i];
        }
    }
}
long long ask(long long l,long long r){
    long long ans = 0; 
    int  p = pos[l],q = pos[r];
    if(p == q) for(int i = l; i <= r; i++) ans += a[i];
    else {
        for(long long i = p+1; i <= q-1; i++) ans += sum[i];
        for(int i =l; i <= R[p]; i++) ans+= a[i];
        for(long long i  = L[q]; i <= r; i++) ans += a[i];
    }
    return ans;
}
int main(){
    cin>>n;
    memset(vis, false, sizeof(vis));
    int len = sqrt(n);
    for(long long i = 1; i <= n; i++) cin>>a[i];
    for(long long i = 1; i <= n; i++){
        pos[i] = (i-1)/len+1;
        L[pos[i]] = 23333333;
    }
    for(long long i = 1; i <= n; i++){
        L[pos[i]] = min(L[pos[i]],i);
        R[pos[i]] = max(R[pos[i]],i);
    }
    for(int i = 1; i <= n/len+1; i++){//预处理每个块的和
        for(int j = L[i]; j <= R[i]; j++){
            sum[i]+=a[j];
        }
    }
    cin>>m;
    for(long long i = 1; i <= m; i++){
        cin>>k>>l>>r;
        if(l > r) swap(l,r);
        if( k == 0) chenge(l,r);
        else cout<<ask(l,r)<<endl;
    }
    return 0;
}

关于这道题，你还可以用线段树做，并且要比分块快QAQ。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
using namespace std;
const int N = 1e5+100;
long long n,m,k,l,r;
long long a[N],pos[N],L[N],R[N],sum[N];
bool vis[N];
void check(long long x){
    if(vis[x]) return;
    vis[x] = 1;
    sum[x] = 0;
    for(int i = L[x]; i <= R[x]; i++){
        a[i] = sqrt(a[i]);
        sum[x] += a[i];
        if(a[i] > 1) vis[x] = 0;
    }
}
void chenge(long long l,long long r){
    int p = pos[l],q = pos[r];
    if(p == q){
        for(int i = l; i <= r; i++){
            sum[p] -=a[i];
            a[i] = sqrt(a[i]);
            sum[p] += a[i];
        }
    } 
    else {
        for(int i = p+1; i <= q-1; i++) check(i);
        for(int i = l; i <= R[p]; i++){
            sum[p] -=a[i];
            a[i] = sqrt(a[i]);
            sum[p] += a[i];
        }
        for(int i = L[q]; i <= r; i++){
            sum[q] -= a[i];
            a[i] = sqrt(a[i]);
            sum[q] += a[i];
        }
    }
}
long long ask(long long l,long long r){
    long long ans = 0; 
    int  p = pos[l],q = pos[r];
    if(p == q) for(int i = l; i <= r; i++) ans += a[i];
    else {
        for(long long i = p+1; i <= q-1; i++) ans += sum[i];
        for(int i =l; i <= R[p]; i++) ans+= a[i];
        for(long long i  = L[q]; i <= r; i++) ans += a[i];
    }
    return ans;
}
int main(){
    cin>>n;
    memset(vis, false, sizeof(vis));
    int len = sqrt(n);
    for(long long i = 1; i <= n; i++) cin>>a[i];
    for(long long i = 1; i <= n; i++){
        pos[i] = (i-1)/len+1;
        L[pos[i]] = 23333333;
    }
    for(long long i = 1; i <= n; i++){
        L[pos[i]] = min(L[pos[i]],i);
        R[pos[i]] = max(R[pos[i]],i);
    }
    for(int i = 1; i <= n/len+1; i++){
        for(int j = L[i]; j <= R[i]; j++){
            sum[i]+=a[j];
        }
    }
    cin>>m;
    for(long long i = 1; i <= m; i++){
        cin>>k>>l>>r;
        if(l > r) swap(l,r);
        if( k == 0) chenge(l,r);
        else cout<<ask(l,r)<<endl;

第二题 P2801 教主的魔法

这个题大致就是区间加和区间询问小于k的数。

对于每个询问，可以先将这个块排好序，然后二分查找k的值就行了。散块直接暴力查询没有排序的原序列。

怎么修改呢？？？

对于整块，我们可以打上 lazy 标记，查询时直接查 >= k - lazy 的值；

对于散块，直接暴力修改，在直接排个序就okk了。

 

例三 zcl的妹

例三 ZCL的妹子

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
const int N = 1e6+10;
#define LL long long
char opt;
int n,m,x,y,len;
int L[N],R[N];
LL sum[N],size[N],a[N],pos[N],cnt[N];
inline int read()
{
    int s = 0, w = 1; char ch = getchar();
    while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}
    while(ch >= '0'&&ch <= '9'){s = s * 10 +ch -'0'; ch = getchar();}
    return s * w;
}
void chenge1(int x,int y)
{
    if(!cnt[x]) return ;
    int xx = pos[x];
    sum[xx] -= y;
    a[x] -= y;
}
void chenge2(int x,int y)
{
    int xx = pos[x];
    if(cnt[x] == 1)
    {
        sum[xx] -= a[x];
        a[x] = y;
        sum[xx] += a[x];
     }
     else{
         cnt[x] = 1;
         sum[x] -= a[x];
         a[x] = y;
         size[xx]++;
         sum[xx] += a[x];
     }
}
void chenge3(int x)
{
     int p = 1;
     while(x - size[p] > 0) x -= size[p], p++;
     for(int i = L[p]; i <= R[p]; i++)
     {
         x -= cnt[i];
         if(x == 0)
         {
             size[p]--;
             sum[p] -= a[i];
             cnt[i] = a[i] = 0;
             return ;
         }
     } 
}
LL ask()
{
    LL ans = 0;
    for(int i = 1; i <= pos[500000]; i++) ans += sum[i];
    return ans;
}
int main()
{
    n = read(); m = read();
    len = sqrt(500000);
    for(int i = 1; i <= n; i++) a[i] = read(),cnt[i] = 1;
    for(int i = 1; i <= 500000; i++)
    {
        pos[i] = (i-1)/len+1;
        L[pos[i]] = 23333333;
    }
    for(int i = 1; i <= 500000; i++)
    {
        size[pos[i]] += cnt[i];
        L[pos[i]] = min(L[pos[i]] , i);
        R[pos[i]] = max(R[pos[i]] , i);
        sum[pos[i]] += a[i]; 
    }
    for(int i = 1; i <= m; i++)
    {
        cin>>opt;
        if(opt == 'C')
        {
            x = read(); y = read();
            chenge1(x,y);
        }
        if(opt == 'I')
        {
            x = read(); y = read();
            chenge2(x,y);
        }
        if(opt == 'D')
        {
            x = read();
            chenge3(x);
        }
        if(opt == 'Q') printf("%lld\n",ask());
    }
    return 0;
}

第N题：P4168 蒲公英  （这道题我也不会，贼恶心）

这道题题意就是给你一段区间，然后询问区间的最小众数。

首先 a < 1e9先离散化；

然后预处理出两个数组 p[i][j] 表示第i个块到第j个块的最小众数。

                                    s[i][j] 前i个块中 j出现的次数

 如何处理呢

1.  对于s， 直接每一个块扫一遍  。
2.  对于 p ，双重枚举i，j开个数组暴力统计每个数出现多少次就行了。
3. 对于询问操作，残块暴力搞，整块骚操作。所以对于posr - posl <= 2 的情况直接可以暴力搞出来

 4.对于其他的情况，答案要么是整块中的众数，或者残块中的数。对于残块中的数，我们已经预处理了之前数字出现的前缀和，

        所以能很快的求出这个数出现的次数。

       5.对于整块中的众数，我们也可以很快的求出ta在残块中的次数。这样答案就可以出来了。

        

void Treaker()//分块预处理 
{
    for(int i=1;i<=n;++i)
    for(int j=pos[i];j<=pos[n];++j)s[j][a[i]]++;
    
    for(int i=1;i<=pos[n];++i)
    {
        memset(tong,0,sizeof(tong));
        for(int j=i;j<=pos[n];++j)
        {
            p[i][j]=p[i][j-1];
            for(int k=L[j];k<=R[j];++k)
            {
                tong[a[k]]++;
                if((tong[a[k]]>tong[p[i][j]])||(tong[a[k]]==tong[p[i][j]]&&a[k]<p[i][j]))p[i][j]=a[k];
            }
        }
    }
    memset(tong,0,sizeof(tong));
}

比较重要的是

p[i][j]=p[i][j-1]

因为我们需要先继承先前的区间众数，然后才能更新，否则的话就会听取 WA 声一片（据说我们学长神犇就卡在这里好几回）

if(pos[r]-pos[l]<=2)
    {
        int res=0;
        for(int i=l;i<=r;++i)
        {
            ++tong[a[i]];
            if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
        }
        for(int i=l;i<=r;++i)tong[a[i]]=0;
        return res;
    }

int res=0;
    for(int i=l;i<=R[pos[l]];++i)if(!tong[a[i]])tong[a[i]]+=s[pos[r]-1][a[i]]-s[pos[l]][a[i]];
    for(int i=L[pos[r]];i<=r;++i)if(!tong[a[i]])tong[a[i]]+=s[pos[r]-1][a[i]]-s[pos[l]][a[i]];
    for(int i=l;i<=R[pos[l]];++i)
    {
        ++tong[a[i]];
        if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
    }
    for(int i=L[pos[r]];i<=r;++i)
    {
        ++tong[a[i]];
        if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
    }
    int k=p[pos[l]+1][pos[r]-1];
    int lin=s[pos[r]-1][k]-s[pos[l]][k];
    for(int i=l;i<=R[pos[l]];++i)lin+=(a[i]==k);
    for(int i=L[pos[r]];i<=r;++i)lin+=(a[i]==k);
    if(lin>tong[res]||(lin==tong[res]&&k<res))res=k;
    
    for(int i=l;i<=R[pos[l]];++i)tong[a[i]]=0;
    for(int i=L[pos[r]];i<=r;++i)tong[a[i]]=0;
    return res;

最后有几点要注意

1. 注意离散化，否则直接RE到原地起飞。
2. 注意 p 数组的转移，否则 WA 到怀疑人生。
3. 注意分块的边界，否则TLE 到直接原地爆炸。

由于本蒟蒻水平太差，此篇题解参考了神犇（wjlss）的博客，如果有人看不懂的话，这里有链接QAQ  wljss

最后本人代码一直炸，所以附上神犇的代码

#include<algorithm>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
int n,m,tot,len,l,r,ans;
const int N=40010,M=50010,K=510;
int a[N],b[N],pos[N],s[K][N],L[K],R[K],p[K][K],tong[N];
int read()
{
    char ch;int x=0,f=1;
    while(!isdigit(ch=getchar()))
    {(ch=='-')&&(f=-f);}
    while(isdigit(ch))
    {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
    return x*f;
}
int cnt=0;
void yych()//离散化 
{
    len=sqrt(n);
    memset(L,0x3f,sizeof(L));
    for(int i=1;i<=n;++i)
    {
        pos[i]=(i-1)/len+1;
        L[pos[i]]=min(L[pos[i]],i);
        R[pos[i]]=max(R[pos[i]],i);
        a[i]=read();
        b[i]=a[i];  
    }
    sort(b+1,b+1+n);
    tot=unique(b+1,b+1+n)-b-1;
    for(int i=1;i<=n;++i)a[i]=lower_bound(b+1,b+1+tot,a[i])-b;
}
void Treaker()//分块预处理 
{
    for(int i=1;i<=n;++i)
    for(int j=pos[i];j<=pos[n];++j)s[j][a[i]]++;

    for(int i=1;i<=pos[n];++i)
    {
        memset(tong,0,sizeof(tong));
        for(int j=i;j<=pos[n];++j)
        {
            p[i][j]=p[i][j-1];
            for(int k=L[j];k<=R[j];++k)
            {
                tong[a[k]]++;
                if((tong[a[k]]>tong[p[i][j]])||(tong[a[k]]==tong[p[i][j]]&&a[k]<p[i][j]))p[i][j]=a[k];
            }
        }
    }
    memset(tong,0,sizeof(tong));
}
int ask(int l,int r)
{
    if(pos[r]-pos[l]<=2)
    {
        int res=0;
        for(int i=l;i<=r;++i)
        {
            ++tong[a[i]];
            if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
        }
        for(int i=l;i<=r;++i)tong[a[i]]=0;
        return res;
    }
    int res=0;
    for(int i=l;i<=R[pos[l]];++i)if(!tong[a[i]])tong[a[i]]+=s[pos[r]-1][a[i]]-s[pos[l]][a[i]];
    for(int i=L[pos[r]];i<=r;++i)if(!tong[a[i]])tong[a[i]]+=s[pos[r]-1][a[i]]-s[pos[l]][a[i]];
    for(int i=l;i<=R[pos[l]];++i)
    {
        ++tong[a[i]];
        if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
    }
    for(int i=L[pos[r]];i<=r;++i)
    {
        ++tong[a[i]];
        if(tong[a[i]]>tong[res]||(tong[a[i]]==tong[res]&&a[i]<res))res=a[i];
    }
    int k=p[pos[l]+1][pos[r]-1];
    int lin=s[pos[r]-1][k]-s[pos[l]][k];
    for(int i=l;i<=R[pos[l]];++i)lin+=(a[i]==k);
    for(int i=L[pos[r]];i<=r;++i)lin+=(a[i]==k);
    if(lin>tong[res]||(lin==tong[res]&&k<res))res=k;

    for(int i=l;i<=R[pos[l]];++i)tong[a[i]]=0;
    for(int i=L[pos[r]];i<=r;++i)tong[a[i]]=0;
    return res;
}
int main()
{
    cin>>n>>m;
    yych();
    Treaker();
    for(int i=1;i<=m;++i)
    {
        l=read();r=read();
        l=(l+ans-1)%n+1;r=(r+ans-1)%n+1;
        if(l>r)swap(l,r);
        ans=b[ask(l,r)];
        printf("%d\n",ans);
    }
    return 0;
}

然后你就可以AC 一道紫题（据说前几年这个还是一道黑题）

最后，分块的东西也就这么多，主要理解小块暴力，整块瞎搞就可以了。

最后附上习题。

1. Karen and coffee
2. 蒲公英
3. 线段树2
4. 定价 （河北15年省选题，思考出怎么分块就可以轻松AC了）