分块

分块复杂度略微证明:

[n：序列的长度；\ S：将这个序列分成S块；\ C：分成的每个块内有C个元素；\ x：查询或修改时，需要操作的整块数；\ y：查询或修改时，需要操作的零散区间中元素个数；\ L：查询或修改时，操作序列的长度。 \ S*C=n我们肯定要让x+y最小\ 最坏情况操作区间为[2,n-1],此时需要查询S−2个块和2C−2个元素\，即x=S−2,y=2C−2。 x+y=S−2+2C−2=S+2C−4。\忽略常数，得x+y=S+C 因SC=n，则C=nS。\ 代入，得x+y=S+nS≥2sqrt n\ 当且仅当S=nS，即S=sqrt n时，等号成立。所以在最坏时，时间复杂度为O(sqrt n)。常数不超过3\ 在一般情况下时，可以得出L=xC+y。移项，得x=L−yC。\ 因0<Lle n,0<y<2C，则0<L−y<n−2C。\ 因C>0，则frac{L-y}{C}<frac{n-2C}{C}=frac{SC-2C}{C}=S-2<S \ 故x+y<S+2C，忽略常数，x+y<S+C。\ 因SC=n，S+Cge 2sqrt{SC}。当且仅当S=C，即S=C=sqrt n时，等号成立。\ 此时x+y<sqrt n。综上，分块的时间复杂度为O(sqrt n)，常数不超过3。证毕 ]

转载该文：https://blog.csdn.net/HeRaNO/article/details/55219560?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-3.nonecase

小花的题解qwq
分块相对其他数据结构优点:通用,码量较小,直观,不易出错,兼容性强

分块实现的基本框架：
划分块，预处理，操作或查询。
操作或查询通常为4步：
1.判断要操作或是查询的区间是否在一个块内
2.若在一个块内，暴力操作或查询
3.若不在一个块内，将除了最左边和最右边这两个块外其余的块进行整体的操作，即直接对块打上修改标记之类的
4.单独暴力处理最左边的块和最右边的块

同时分块的块内还可以使用别的数据结构或是操作以实现要求或进一步优化复杂度

把数列分成长度若干长度不超过(lfloorsqrt n floor)的段,其中第(i)段的左端点为((i-1)lfloorsqrt n floor+1),右端点为(min(ilfloorsqrt n floor,n))

预处理数组(sum),其中(sum[i])表示(i)段区间和,设(add[i])表示第(i)段的增量标记,起初(add[i]=0)

对于指令区间加操作

1.若(l)和(r)同时位于第(i)段内,把(A[l]...A[r])全部(+d),令(sum[i]+=d*(r-l+1))

2.若(l)处于第(p)段(r)处于第(q)段.

(1).对于(iin[p+1,q-1],令add[i]+=d) (2).对于开头，结尾不足一整段的两部分,按照与第一种情况相同的方法朴素的更新

对于区间和的操作

1.若(l与r)同时位于(i)段内,则((A[l]+A[l+1]+...+A[r])+(r-l+1)*add[i])就是答案

2.若(l)处于第(p)段,(r)处于第(q)段, (ans+=sum[i]+add[i]*len[i],len[i]为第i段长度)

（2）对于开头结尾不足一整段,暴力维护

(复杂度O((N+Q)*sqrt N)),核心思想:大段维护,小段暴力

libre oj分块入门1

#include<cstdio>
#include<cmath>
#include<iostream>
#define maxn 50005
using namespace std;
int a[maxn],add[250],pos[maxn],block;
//a原数组,pos每个位置属于哪段 

void adde(int x,int y,int z){
	 for (int i = x; i <= min(pos[x] * block, y); i++)//处理左端点所在的不完整的块
        a[i] += z;
    if (pos[x] != pos[y])//如果左右端点不在一个块里处理右端点所在的不完整的块
        for (int i = (pos[y] - 1) * block + 1; i <= y; i++)
            a[i] += z;
    for (int i = pos[x] + 1; i <= pos[y] - 1; i++)//处理中间完整的区间
        add[i] += z;
}
int main(){
	int n,opt,c,l,r;
	scanf("%d",&n);
	block = sqrt(n);
	for(int i=1;i<=n;i++)
	scanf("%d",&a[i]);
	for(int i=1;i<=n;i++)
	pos[i] = (i - 1) / block + 1;
	for(int i=1;i<=n;i++)
	{
		scanf("%d%d%d%d",&opt,&l,&r,&c);
		if(!opt) adde(l,r,c);
		else printf("%d
",a[r]+add[pos[r]]);
	}
}

分块入门2

#include <bits/stdc++.h>
#define ll long long
using namespace std;
int n, block;
const int MAXN = 5e4 + 10;
const int block_ = 250;
int w[MAXN], b[MAXN], lazy[block_];
vector<int> v[block_];
void spread(int x)  //将不完整的块压入vector重新排序
{
    v[x].clear();
    int l = (x - 1) * block + 1, r = min(x * block, n);
    for (int i = l; i <= r; i++) v[x].push_back(w[i]);
    sort(v[x].begin(), v[x].end());
}
void add(int x, int y, int z) {
    for (int i = x; i <= min(b[x] * block, y); i++) w[i] += z;
    if (b[x] != b[y]) {
        for (int i = (b[y] - 1) * block + 1; i <= y; i++) w[i] += z;
        spread(b[y]);
    }
    for (int i = b[x] + 1; i <= b[y] - 1; i++) lazy[i] += z;
    spread(b[x]);
}
ll ans(int x, int y, int z) {
    int sum = 0;
    int big = z * z;
    for (int i = x; i <= min(b[x] * block, y); i++)
        if (w[i] + lazy[b[i]] < big)
            sum++;
    if (b[x] != b[y])
        for (int i = (b[y] - 1) * block + 1; i <= y; i++)
            if (w[i] + lazy[b[i]] < big)
                sum++;
    for (int i = b[x] + 1; i <= b[y] - 1; i++)
        sum += lower_bound(v[i].begin(), v[i].end(), big - lazy[i]) -
               v[i].begin();  // STL大法好，自带二分查找，查找第一个大于等于查找元素的下标（vector从0开始）
    return sum;
}
int main() {
    ios::sync_with_stdio(false);
    cin >> n;
    block = sqrt(n);
    for (int i = 1; i <= n; i++) {
        cin >> w[i];
        b[i] = (i - 1) / block + 1;
        v[b[i]].push_back(w[i]);
    }
    for (int i = 1; i <= b[n]; i++) sort(v[i].begin(), v[i].end());
    for (int i = 1; i <= n; i++) {
        int opt, x, y, z;
        cin >> opt >> x >> y >> z;
        if (!opt)
            add(x, y, z);
        else
            cout << ans(x, y, z) << endl;
    }
    return 0;
}