Description

給你N個數組成的序列，需要支援兩種操作

• 1 L R x 將L到R加上x
• 2 L R k 求L到R第k小的數

Solution

分塊大法好！

我們將序列分成N−−√塊，每塊中維護原來的順序的值，以及將該塊所有值排序後的值，並且每個值還帶有一個指標指向對應的那個值

修改整塊的就直接打標記，兩邊的暴力重構該塊

關鍵在查詢！

我們可以二分一個答案（思考一下，二分出來的答案會不會序列中不存在呢？）

然後轉化成判定性問題，判斷二分出來的答案是不是在第k大

只需要對於每個塊，找該塊中小於這個值的個數，全部加起來看是不是k−1，然後逼近答案。

證明一下這樣為什麼不會出現不存在的答案

假設正確答案是s,那麼二分出大於s的答案顯然不可能，因為個數一定要加上s本身這一個

小於等於s，都有可能等於k−1，然而二分出來的答案是這些值中的最大值（自己想為什麼）

所以二分出來的一定是s

Code

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cmath>
#define fo(i,a,b) for(i=a;i<=b;i++)
 

#define fod(i,a,b) for(i=a;i>=b;i--)
#define mo 1000000007
using namespace std;
int pl[500],wz[80605],n,m,size;
struct note
{
    int x,y;
}a[80605],b[80605];
bool cmp(note x,note y)
{
    return x.x<y.x; 
}
int nt(int k)
{
    return ((k-1)/size+1)*size+1;
}
int pd(int l,int r,int k)
{
    int p=nt(l),sum=0,i;
    note k1;
    k1.x=k;
    while
 
 (nt(p)<r+1)
    {
        k1.x-=pl[wz[p]];
        sum+=lower_bound(b+p,b+nt(p),k1,cmp)-b-p;
        k1.x+=pl[wz[p]];
        p=nt(p); 
    } 
    if (nt(l)>r)
    {
        fo(i,l,r) if (a[i].x<k-pl[wz[i]]) sum++;
    }
    else 
    {
        fo(i,l,nt(l)-1) if (a[i].x<k-pl[wz[i]]) sum++;
        fo(i,p,r) if (a[i].x<k-pl[wz[i]]) sum++;
    }
    return sum;

}
int main()
{
    int i,j;
    cin>>n;
    size=(int)sqrt(n);
    fo(i,1,n)
    {
        scanf("%d",&a[i].x);
        b[i].x=a[i].x;
        b[i].y=i;
    } 
    j=1;
    wz[j]=1;
    while (j+size<=n+1)
    {
        sort(b+j,b+j+size,cmp);
        j+=size;
        wz[j]=wz[j-size]+1;
    }
    if(j!=n+1) sort(b+j,b+n+1,cmp);
    fo(i,1,n) 
    {
        if (wz[i]==0) wz[i]=wz[i-1]; 
        a[b[i].y].y=i;
    }
    cin>>m;
    int i1=0;
    fo(i,1,m)
    {
        int p,l,r,k,j;
        scanf("%d%d%d%d",&p,&l,&r,&k);
        if (p==1)
        {
            j=nt(l); 
            while (nt(j)<=r)
            {
                pl[wz[j]]+=k;
                j=nt(j);
            } 
            int q;
            if (nt(l)>r)
            {
                fo(q,l,r) a[q].x=b[a[q].y].x=a[q].x+k;
                sort(b+nt(l)-size,b+nt(l),cmp);
                fo(q,nt(l)-size,nt(l)-1) a[b[q].y].y=q;
            }
            else 
            {
                fo(q,l,nt(l)-1) a[q].x=b[a[q].y].x=a[q].x+k;
                sort(b+nt(l)-size,b+nt(l),cmp);
                fo(q,nt(l)-size,nt(l)-1) a[b[q].y].y=q;

                fo(q,j,r) a[q].x=b[a[q].y].x=a[q].x+k;
                sort(b+j,b+nt(j),cmp);
                fo(q,j,nt(j)-1) a[b[q].y].y=q;
            }
        }
        else
        {
             int x=-5000000,y=5000000,mid;
             while (x<y-1)
             { 
                mid=(x+y)/2;
                if (pd(l,r,mid)<=k-1) x=mid;
                else y=mid;
             }
             if (pd(l,r,y)==k-1) printf("%d\n",y);
             else printf("%d\n",x); 
        }
    }
}