分块入门
基本思想
把一个需要操作的序列分成若干块，分别处理，从而优化时间复杂度。
容易证明块长为 \(\sqrt n\) 时复杂度最优。
分块常规单次操作复杂度为 \(\mathcal{O}(\sqrt n)\)，一般可以当做 \(\mathcal{O}(\log^2n)\) 来计算复杂度。
接下来给几道例题。
T1
给出一个长为 \(n\) 的数列，以及 \(n\) 个操作，操作涉及区间加法，单点查值。
就当模板放了。
点击查看代码
void add(int l,int r,int c)
{
int sid=id[l],eid=id[r];
if(sid==eid)
{
for(int i=l;i<=r;i++)
a[i]+=c;
return ;
}
for(int i=l;id[i]==sid;i++)a[i]+=c;
for(int i=sid+1;i<eid;i++)tag[i]+=c;
for(int i=r;id[i]==eid;i--)a[i]+=c;
}
T2
给出一个长为 \(n\) 的数列，以及 \(n\) 个操作，操作涉及区间加法，询问区间内小于某个值 \(x\) 的元素个数。
对于区间加法，类似线段树设置懒标记，对于查询操作，可以用二分解决。我们每次区间加法之后对所有涉及到的不完整区间重新排序，保证可以二分找到给定值，对于完整区间，由于顺序不变，则更新 \(tag\) 值即可。
具体的，我们对于每一个块，用一个 \(vector\) 记录值，每次排序对 \(vector\) 排序，可以证明复杂度正确。
放一下查询和更新的代码：
点击查看代码
void work(int x)
{
v[id[x]].clear();
for(int i=(id[x]-1)*len+1;i<=min(n,id[x]*len);i++)
v[id[x]].push_back(a[i]);
sort(v[id[x]].begin(),v[id[x]].end());
}
int ask(int l,int r,int c)
{
int sid=id[l],eid=id[r],ans=0;
if(sid==eid)
{
for(int i=l;i<=r;i++)if(a[i]+tag[id[l]]<c)ans++;
return ans;
}
for(int i=l;id[i]==sid;i++)if(a[i]+tag[id[l]]<c)ans++;
for(int i=sid+1;i<eid;i++)ans+=lower_bound(v[i].begin(),v[i].end(),c-tag[i])-v[i].begin();
for(int i=r;id[i]==eid;i--)if(a[i]+tag[id[r]]<c)ans++;
return ans;
}
T3
给出一个长为 \(n\) 的数列，以及 \(n\) 个操作，操作涉及区间加法，询问区间内小于某个值 \(x\) 的前驱（比其小的最大元素）。
和上一道题很类似，只是对于查询操作，我们二分找到每个块里面符合条件的最大值，取总最大值即可。
查询部分：
点击查看代码
int sid=id[l],eid=id[r],ans=-1;
if(sid==eid)
{
for(int i=l;i<=r;i++)if(a[i]+tag[id[l]]<c)ans=max(ans,a[i]+tag[id[l]]);
return ans;
}
for(int i=l;id[i]==sid;i++)if(a[i]+tag[id[l]]<c)ans=max(ans,a[i]+tag[id[l]]);
for(int i=sid+1;i<eid;i++)
{
int x=c-tag[i];
int y=lower_bound(v[i].begin(),v[i].end(),x)-v[i].begin();
if(--y>=0)
ans=max(ans,v[i][y]+tag[i]);
}
for(int i=r;id[i]==eid;i--)if(a[i]+tag[id[r]]<c)ans=max(ans,a[i]+tag[id[r]]);
return ans;
T4
给出一个长为 \(n\) 的数列，以及 \(n\) 个操作，操作涉及区间加法，区间求和。
简单，模拟线段树的思路，记录区间懒标记 \(tag\)，修改的时候对于完整区间只更新 \(tag\) 值，查询的时候对于不完整的块，让每个元素加上他所在区间的 \(tag\) 值累加，对于完整的块，则让区间和加上 \(tag\times len\)(\(len\) 为块长)后累加答案即可。
太简单，代码不放了。
T5
给出一个长为 \(n\) 的数列，以及 \(n\) 个操作，操作涉及区间开方，区间求和。
势能分析，由于 \(\sqrt 1=1\)，所以我们用一个布尔数组 \(f\) 表示当前块是否已经全部小于等于 \(1\)，每次修改的时候对于 \(f_i\le 1\) 的块跳过，否则暴力修改即可。
整块修改部分代码：
点击查看代码
for(int i=sid+1;i<eid;i++)
if(!f[i])
{
f[i]=1;
for(int j=(i-1)*len+1;j<=min(n,i*len);j++)
{
tag[i]=tag[i]-a[j]+sqrt(a[j]);
a[j]=sqrt(a[j]);
if(a[j]!=0&&a[j]!=1)
f[i]=0;
}
}
T6
给出一个长为 \(n\) 的数列，以及 \(n\) 个操作，操作涉及单点插入，单点询问。
其实稍微想一想就发现，我们只需要维护每一个块的内部排列即可，对于每个修改操作，在块内正常暴力修改，对于每个查询操作，从 \(1\) 开始跑，每次减去当前块长，最后直接输出即可。
放一下代码：
点击查看代码
void add(int x,int k)
{
int sum=0;
for(int i=1;i;i++)
{
if(x<v[i].size())
{
v[i].push_back(maxn);
for(int j=v[i].size()-1;j>x;j--)
{
v[i][j]=v[i][j-1];
}
v[i][x]=k;
return ;
}
x-=v[i].size();
}
}
void ask(int x)
{
int sum=0;
for(int i=1;;i++)
{
if(x<v[i].size()) {cout<<v[i][x]<<'\n';return ;}
x-=v[i].size();
}
}
T7
给出一个长为 \(n\) 的数列，以及 \(n\) 个操作，操作涉及区间乘法，区间加法，单点询问。
左转线段树，模拟懒标记就行了。有点难写，所以代码不放了。
T8
给出一个长为 \(n\) 的数列，以及 \(n\) 个操作，操作涉及区间询问等于一个数 \(c\) 的元素，并将这个区间的所有元素改为 \(c\)。
我们对每个区间记录一个 \(tag\)，代表是否被全部赋值并且赋值成了什么。每次操作的时候先对左右两个不完整的区间根据 \(tag\) 重新赋值，并更新 \(tag\)，然后对于中间的区间，如果该区间 \(tag\) 有值，累加答案并修改区间 \(tag\)，否则暴力修改，复杂度可以证明是正确的。
放一下区间修改的代码：
点击查看代码
for(int i=sid+1;i<eid;i++)
if(tag[i]!=-1)
{
if(tag[i]!=c)tag[i]=c;
else ans+=len;
}
else
{
for(int j=(i-1)*len+1;j<=i*len;j++)
{
if(a[j]!=c)a[j]=c;
else ans++;
}
tag[i]=c;
}
分块是一种很有用的算法，希望大家勤加练习。
