分块

　　今天决定要学分块!

　　于是就先开这么一篇blog吧.

　　看了一眼数列分块9题,吓哭了~分块这么有用的吗

　　

　　数列分块1：https://loj.ac/problem/6277

　　从这道题开始数列分块的旅程~

　　题意概述：长度为$50000$的序列,区间加,单点查询.

　　分块其实就是暴力...只不过经过一番玄学分析复杂度竟然还很不错。我们将序列分成$m$块,每次修改时对于整块直接打标记,对于散块暴力修改,显然当$m=\sqrt{n}$的时候两种修改的复杂度都是比较优秀的。因为每次最多对于$\sqrt{n}$个整块打标记,零散部分最多也只有$2*\sqrt{n}$个.既然分块本来就比较暴力,那就多卡卡常吧,这里提供一个很科学的卡常方法,对于两边的零散部分,如果发现要修改的长度大于块长的一半,就给整个块打上修改标记,再把范围外的多余部分减去.这样算出来零散部分就最多只有$\sqrt{n}$个了.这个卡常的效果极其不明显...码量却多了好多.总复杂度$O(N\sqrt{N})$

　　　

　　

# include <cstdio>
# include <iostream>
# include <cmath>
# define R register int

using namespace std;

const int maxn=50004;
int l,r,c,opt,n,siz;
int a[maxn],b[maxn],delta[maxn];

void add (int l,int r,int v)
{
    if(b[l]==b[r])
    {
        for (R i=l;i<=r;++i)
            a[i]+=v;
    }
    else
    {
        if(b[l]*siz-l>l-(1+b[l]*siz-siz))
        {
            for (R i=1+b[l]*siz-siz;i<l;++i) a[i]-=v;
            delta[ b[l] ]+=v;
        }
        else
            for (R i=l;i<=b[l]*siz;++i) a[i]+=v;
        for (R i=b[l]+1;i<=b[r]-1;++i) delta[i]+=v;
        if(b[r]*siz-r>r-(1+b[r]*siz-siz))
            for (R i=1+b[r]*siz-siz;i<=r;++i) a[i]+=v;
        else
        {
            for (R i=r+1;i<=b[r]*siz;++i) a[i]-=v;
            delta[ b[r] ]+=v;
        }
    }
}

int main()
{
    scanf("%d",&n);
    for (R i=1;i<=n;++i) scanf("%d",&a[i]);
    siz=sqrt(n);
    for (R i=1;i<=n;++i) b[i]=(i-1)/siz+1;
    for (R i=1;i<=n;++i)
    {
        scanf("%d%d%d%d",&opt,&l,&r,&c);
        if(opt==0)
            add(l,r,c);
        else
            printf("%d\n",a[r]+delta[ b[r] ]);
    }
    return 0;
}

 

　　数列分块2:https://loj.ac/problem/6278

　　题意概述：长度为$50000$$的序列,区间加,区间查询小于某个数的数字个数。$

$本来以为至少要树套树，没想到分块这么神奇。$

$对于每一块先排序，散的部分暴力找，其他部分在块内二分。注意！因为排完序后块内的下标就不连续了，所以不能再按照下标修改，散块必须全部遍历来修改。修改完后再次排序以保证有序性。$　　

　　

# include <cstdio>
# include <iostream>
# include <cmath>
# include <algorithm>
# define R register int
# define ll long long
# define P(i) sort(a+1+siz*(i-1),a+1+min(siz*i,n),cmp)

using namespace std;

const int maxn=100004;
int id,n,siz,opt,l,r,c,ans;
ll delta[maxn];
struct dig
{
    int b,k;
    ll v;
}a[maxn];

bool cmp (dig a,dig b) { return a.v<b.v; }

void add (int l,int r,ll c)
{
    if(a[l].b==a[r].b)
    {
        id=a[l].b;
        for (R i=1+siz*(id-1);i<=min(id*siz,n);++i)
            if(a[i].k>=l&&a[i].k<=r) a[i].v+=c;
        P(a[l].b);
    }
    else
    {
        id=a[l].b;
        for (R i=1+siz*(id-1);i<=min(siz*id,n);++i)
            if(a[i].k>=l&&a[i].k<=r)
                a[i].v+=c;
        P(id);
        for (R i=a[l].b+1;i<=a[r].b-1;++i) delta[i]+=c;
        id=a[r].b;
        for (R i=1+siz*(id-1);i<=min(siz*id,n);++i)
            if(a[i].k>=l&&a[i].k<=r)
                a[i].v+=c;
        P(id);
    }
}

int check (int x,ll c)
{
    int l=1+siz*(x-1),r=min(n,siz*x),mid,ans=siz*(x-1);
    while (l<=r)
    {
        mid=r+((l-r)>>1);
        if(a[mid].v+delta[ a[mid].b ]<c)
            l=mid+1,ans=max(ans,mid);
        else
            r=mid-1;            
    }
    return ans-siz*(x-1);
}

int ask (int l,int r,ll c)
{
    int ans=0,id;
    if(a[l].b==a[r].b)
    {
        id=a[l].b;
        for (R i=1+siz*(id-1);i<=min(siz*id,n);++i)
            if(a[i].k>=l&&a[i].k<=r&&a[i].v+delta[ a[i].b ]<c)
                ans++;
    }
    else
    {
        id=a[l].b;
        for (R i=1+siz*(id-1);i<=min(siz*id,n);++i)
            if(a[i].k>=l&&a[i].k<=r&&a[i].v+delta[ a[i].b ]<c)
                ans++;
        for (R i=a[l].b+1;i<=a[r].b-1;++i)
            ans+=check(i,c);    
        id=a[r].b;
        for (R i=1+siz*(id-1);i<=min(siz*id,n);++i)
            if(a[i].k>=l&&a[i].k<=r&&a[i].v+delta[ a[i].b ]<c)
                ans++;
    }
    return ans;
}

int main()
{
    scanf("%d",&n);
    siz=sqrt(n);
    for (R i=1;i<=n;++i)
    {
        scanf("%lld",&a[i].v);
        a[i].k=i;
        a[i].b=(i-1)/siz+1;
    }
    for (R i=1;i<=a[n].b;++i) P(i);
    for (R i=1;i<=n;++i)
    {
        scanf("%d%d%d%d",&opt,&l,&r,&c);
        if(opt)
        {            
            ans=ask(l,r,1LL*c*c);
            printf("%d\n",ans);
        }
        else 
            add(l,r,c);
    }
    return 0;
}

  

　　数列分块3:https://loj.ac/problem/6279

　　数列分块4:https://loj.ac/problem/6280

　　题意概述：长度为$50000$$的序列,区间加,区间求和.$

$和\$1\$是一样的思路，对于每一个块再记录一个\$sum\$,整块一起加,散的部分暴力加即可.$

　　

# include <cstdio>
# include <iostream>
# include <cmath>
# include <algorithm>
# define R register int

using namespace std;

const int maxn=50004;
int n,b[maxn],opt,l,r,c,siz;
long long a[maxn],delta[maxn],s[maxn];

void add (int l,int r,int c)
{
    if(b[l]==b[r]) for (R i=l;i<=r;++i) a[i]+=c,s[ b[i] ]+=c;
    else
    {
        for (R i=l;i<=siz*b[l];++i) a[i]+=c,s[ b[i] ]+=c;
        for (R i=b[l]+1;i<=b[r]-1;++i) delta[i]+=c,s[i]+=siz*c;
        for (R i=1+siz*(b[r]-1);i<=r;++i) a[i]+=c,s[ b[i] ]+=c;
    }
}

int ask (int l,int r,int mod)
{
    long long ans=0;
    if(b[l]==b[r]) for (R i=l;i<=r;++i) ans=(ans+a[i]+delta[ b[i] ])%mod;
    else
    {
        for (R i=l;i<=siz*b[l];++i) ans=(ans+a[i]+delta[ b[i] ])%mod;
        for (R i=b[l]+1;i<=b[r]-1;++i) ans=(ans+s[i])%mod;
        for (R i=1+siz*(b[r]-1);i<=r;++i) ans=(ans+a[i]+delta[ b[i] ])%mod;
    }
    return ans%mod;
}

int main()
{
    scanf("%d",&n);
    siz=sqrt(n);
    for (R i=1;i<=n;++i) scanf("%lld",&a[i]);
    for (R i=1;i<=n;++i) b[i]=(i-1)/siz+1,s[ b[i] ]+=a[i];
    for (R i=1;i<=n;++i)
    {
        scanf("%d%d%d%d",&opt,&l,&r,&c);
        if(opt) printf("%d\n",ask(l,r,c+1));
        else add(l,r,c);
    }
    return 0;
}

 

　　数列分块5:https://loj.ac/problem/6281

　　数列分块6:https://loj.ac/problem/6282

　　数列分块7:https://loj.ac/problem/6283

　　数列分块8:https://loj.ac/problem/6284

　　数列分块9:https://loj.ac/problem/6285

 

　　普通计算姬：https://www.lydsy.com/JudgeOnline/problem.php?id=4765

　　给定一棵有根带权树，要求支持单点修改及一个区间内所有点的子树和的和。

　　$n,m<=10^5$

　　首先从网上抄一个简单的做法：

　　首先根据编号分块，并预处理一个数组 $a[i][j] $ 表示第 $i$ 个点的值对第 $j$ 个块内答案的影响，查询时整块直接用算好的答案，零散的部分利用 $dfs$ 序一个一个地算子树和，又快又好写。$O(M\sqrt{N}logN)$

　　但是这不是重点。

　　着重讲一下我的又慢又难写的做法：

　　每个点会影响哪些点的子树和呢？显然是它的祖先们啦。

　　那么修改一个点，影响的就是一条链，想到了树链剖分。

　　首先对于原树进行链剖，按照dfs序分块，块内以原编号为关键字排序。平常写的链剖套线段树居多，但是这里使用链剖套分块，修改比较显然。查询时遍历每一个块，用二分求出块内哪部分包含于询问区间，因为块内排过序所以这个部分是连续的，块内再使用树状数组求前缀和。看起来像是两个log过不了，但是有一个log是套在根号外面的，所以勉勉强强卡过了。看起来并不是很复杂，但是写起来是真的复杂...放在这里只是一个纪念，如果能想到第一种还是写第一种比较好。

　　$O(M\times\sqrt{N}\times logN\times log\sqrt{N})$

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <algorithm>
# include <cmath>
# define R register int
# define ULL unsigned long long

using namespace std;

const int N=100005;
const int B=320;
int n,m,a,b,rt,firs[N],h,bel[N],pos,opt,l,r,v,d[N];
int dep[N],siz[N],son[N],Tp[N],id[N],f[N],cnt;
int old[N]; //dfs序为i的点的原编号为old[i] 
int block_cnt,block_siz;
struct node { int old_id,dfs_id; };
struct edge { int too,nex; }g[N<<1];
struct block
{
    int l,r,siz; //dfs序的左右，其实也就是把块全部铺开后所占有的区间
    int delta; //整块的标记，没有必要下传
    ULL t[B]; //块内的前缀和（BIT）
    node e[B]; //块内元素
}k[B]; //每个块保存dfs编号连续的一段元素，按照原序号排列
ULL ans,s[N];

inline int read()
{
    R x=0;
    char c=getchar();
    while (!isdigit(c)) c=getchar();
    while (isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x;
}

bool cmp (node a,node b) { return a.old_id<b.old_id; }

void dfs1 (int x)
{
    siz[x]=1;
    s[x]=d[x];
    int j,maxs=-1;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(dep[j]) continue;
        f[j]=x,dep[j]=dep[x]+1;
        dfs1(j);
        siz[x]+=siz[j];
        s[x]+=s[j];
        if(siz[j]>=maxs) maxs=siz[j],son[x]=j;
    }
}

void dfs2 (int x,int tp)
{
    id[x]=++cnt;
    old[ id[x] ]=x;
    Tp[x]=tp;
    if(!son[x]) return ;
    dfs2(son[x],tp);
    int j;
    for (R i=firs[x];i;i=g[i].nex)
    {
        j=g[i].too;
        if(son[x]==j||f[x]==j) continue;
        dfs2(j,j);
    }
}

inline void add (int x,int y)
{
    g[++h].nex=firs[x];
    g[h].too=y;
    firs[x]=h;
}

void ad (int t,int pos,ULL v) { for (R i=pos;i<=k[t].siz;i+=(i&(-i))) k[t].t[i]+=v; }

ULL query (int t,int pos)
{
    ULL ans=0;
    for (R i=pos;i;i-=(i&(-i))) ans+=k[t].t[i];
    return ans;
}

void add (int a,int b,ULL v)
{
    int l,r,id;
    for (R i=1;i<=block_cnt;++i)
    {
        l=k[i].l; r=k[i].r;
        if(a<=l&&r<=b) k[i].delta+=v;
        else if(b>=l&&a<=r)
        {
            for (R j=1;j<=k[i].siz;++j)
            {
                id=k[i].e[j].dfs_id;
                if(a<=id&&id<=b)
                    ad(i,j,v);
            }
        }
    }
}

ULL ask (int id,int a,int b)
{
    ULL ans=0;
    int l,r,mid,lef=-1,rig=-1; //二分找到块内符合条件的部分，树状数组求和
    l=1,r=k[id].siz;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(k[id].e[mid].old_id>=a) lef=mid,r=mid-1;
        else l=mid+1;
    }
    l=1,r=k[id].siz;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(k[id].e[mid].old_id<=b) rig=mid,l=mid+1;
        else r=mid-1;
    }
    if(lef==-1||rig==-1) return ans;
    ans=query(id,rig)-query(id,lef-1);
    ans+=1ULL*k[id].delta*(rig-lef+1);
    return ans;
}

void build()
{
    int cnt;
    bel[0]=-1;
    for (R i=1;i<=n;++i)
    {
        if(bel[i]!=bel[i-1]) cnt=0;
        k[ bel[i] ].e[++cnt].old_id=old[i];
        k[ bel[i] ].e[cnt].dfs_id=i;
    }
    for (R i=1;i<=block_cnt;++i)
        sort(k[i].e+1,k[i].e+k[i].siz+1,cmp);        
    for (R i=1;i<=block_cnt;++i)
        for (R j=1;j<=k[i].siz;++j)
            ad(i,j,s[ k[i].e[j].old_id ]);    
}

void t_add (int x,int y,ULL v)
{
    while (Tp[x]!=Tp[y])
    {
        if(dep[ Tp[x] ]<dep[ Tp[y] ]) swap(x,y);
        add(id[ Tp[x] ],id[x],v);
        x=f[ Tp[x] ];
    }
    if(dep[x]>dep[y]) swap(x,y);
    add(id[x],id[y],v);
}

int main()
{
    n=read(),m=read();
    for (R i=1;i<=n;++i) d[i]=read();
    for (R i=1;i<=n;++i)
    {
        a=read(),b=read();
        if(a==0) rt=b;
        else add(a,b),add(b,a);
    }
    block_siz=sqrt(n);
    for (R i=1;i<=n;++i) bel[i]=i/block_siz+1;
    block_cnt=bel[n];
    for (R i=1;i<=block_cnt;++i) k[i].l=n+1;
    for (R i=1;i<=n;++i) k[ bel[i] ].l=min(k[ bel[i] ].l,i),k[ bel[i] ].r=i; //处理每个块的左右端点
    for (R i=1;i<=block_cnt;++i) k[i].siz=k[i].r-k[i].l+1;
    dep[rt]=1;
    dfs1(rt);
    dfs2(rt,rt);
    build();
    for (R i=1;i<=m;++i)
    {
        opt=read();
        if(opt==1)
        {
            pos=read(),v=read();
            t_add(rt,pos,v-d[pos]);
            d[pos]=v;
        }
        else
        {
            l=read(),r=read();
            ans=0;
            for (R i=1;i<=block_cnt;++i)
                ans+=ask(i,l,r);
            printf("%llu\n",ans);
        }
    }
    return 0;
}
// 首先树剖，按照dfs序分块，块内按照原序号排序，

 

　　Mato的文件管理：https://www.lydsy.com/JudgeOnline/problem.php?id=3289

　　题意概述：区间静态逆序对。

　　这是一道很适合分块的题目，更是一道适合卡常的题目，不过卡了很久也没过那道YNOI，只过了这个普通版。

　　首先将序列分块，那么答案就是：整块与整块之间的逆序对数，整块与散点之间的逆序对数，散点与散点之间的逆序对数。

---shzr