LSNUACM_2021Semester2_Week3Sort——A - 数列分块入门 2

解题思路：

首先我们来分析quary这个操作，我们查询的是一个区间内小于的元素个数，对于非整块来说就是暴力查询即可，但对于整块来说，我们怎样才能更快的知道有多少个元素小于 呢？在这里我们来分析一下：如果这个整块是无序的，那我们就只能是暴力一个一个的判断是否符合条件，显然，在这么大的数据中，暴力是不可能让你过的；好，再来想一想，如果这个块是有序的，是不是就可以更快一点的得到答案呢，是可以的，有序后我们就可以用二分，二分的效率也是很高呐，正解也确实就是二分，这样的话，quary就给分析完毕了。接着，来分析add操作，和第一题的是相差不多的，唯独就是多了个给quary函数便捷的小通道，加了一个很好用vector容器，作用是什么呢，那当然是对某个块进行排顺序所需咯。。（还有就是STL里的lower_bound函数可是要比手写二分简短的多呢）。。在我们更改序列中的元素后，对于整块的来说同时加上相同的元素，相对大小是不变的，也就是说序列顺序未曾改变；但对于非整块的来说，相当于在整块中把一部分元素给增加了，另一部分元素不变，此时这个块儿也就变为无序了。为了方便quary的进行，我们就需要再对这个块进行重新排序操作，至此，add函数差不多也都分析完了。知晓上方我们想要的操作后，需要预处理的除了和第一题相同的L[x],R[x],lazy[x],blong[i]之外，我们需要把每一个快中的元素放入容器中，且在一开始就把已经放入容器中的元素进行排序。

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N=50010;
int n,m,L[N],R[N],block,num,blong[N];
ll a[N],lazy[N];
vector<ll> v[N];

void build()
{
    block=sqrt(n);//每个块的大小，sqrt(n)时复杂度最低
    if(n%block==0) num = n/block;
    else num = n/block + 1;  //最后一个块可能不够block个
    for(int i=1;i<=n;i++)
    {
        blong[i]=(i-1)/block + 1;//块的个数从1开始，So不应写成i/block
        v[blong[i]].push_back(a[i]);
    }
    for(int i=1;i<=num;i++)
    {
        L[i]=(i-1)*block+1,R[i]=i*block;//每个块的左右边界
    }
    R[num] = n; //最后一块特殊处理
    for(int i=1;i<=num;i++)
    {
        sort(v[i].begin(),v[i].end());
    }
}

void resort(int x)//对x块进行排序
{
    v[x].clear();
    for(int i=L[x];i<=R[x];i++)
    {
        v[x].push_back(a[i]);
    }
    sort(v[x].begin(),v[x].end());
}

void update(int l,int r,ll c)
{
    if(blong[l]==blong[r])
    {
        for(int i=l;i<=r;i++)
        {
            a[i]+=c;
        }
        resort(blong[l]);
        return;
    }
    for(int i=l;i<=R[blong[l]];i++)
    {
        a[i]+=c;
    }
    for(int i=blong[l]+1;i<=blong[r]-1;i++)
    {
        lazy[i]+=c;
    }
    for(int i=L[blong[r]];i<=r;i++)
    {
        a[i]+=c;
    }
    resort(blong[l]);
    resort(blong[r]);
}

int quary(int l,int r,ll c)
{
    int ans=0;
    if(blong[l]==blong[r])
    {
        for(int i=l;i<=r;i++)
        {
            if(a[i]+lazy[blong[i]]<c)
            ans++;
        }
        return ans;
    }
    for(int i=l;i<=R[blong[l]];i++)
    {
        if(a[i]+lazy[blong[i]]<c)
        ans++;
    }
    for(int i=blong[l]+1;i<=blong[r]-1;i++)
    {
        //我么要查询的是a[i]+lazy[blong[i]]>=c的第一个位置（vector下标是从零开始的）
        //移项后也就是a[i]>=c-lazy[blong[i]]啦，注意此a[i](指vector容器中的元素)非彼a[i]（指原数组)
        ans += lower_bound(v[i].begin(),v[i].end(),c-lazy[i])-v[i].begin();
    }
    for(int i=L[blong[r]];i<=r;i++)
    {
        if(a[i]+lazy[blong[i]]<c)
        ans++;
    }
    return ans;
}

inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

inline ll Read(){
    ll  x=0;
    bool f=0;
    char ch=getchar();
    while (ch<'0'||'9'<ch)    f|=ch=='-', ch=getchar();
    while ('0'<=ch && ch<='9')
        x=x*10+ch-'0',ch=getchar();
    return f?-x:x;
}

int main()
{
    n=read();
    for(int i=1;i<=n;i++) a[i]=Read();
    build();
    m=n;
    while(m--)
    {
        int op,l,r;
        ll c;
        op=read(),l=read(),r=read();c=Read();
        if(op==0) update(l,r,c);
        else printf("%d\n",quary(l,r,c*c));
    }
    return 0;
}