nefu 复读机、分块加二分

有两个操作，1操作，对于x,y区间内的值全部加1。2操作，求出第一次复读y次跟最后一个复读y次的复读机次数。

a存复读机原数组，b存分块数组，对于分块数组每个进行排序操作，使区间有序，每次查询对于第一个区间查找到最后一个区间，进行二分查找。 

更新时则对两个区间都进行更新。也可对a更新后再对B赋值。

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <math.h>
using namespace std;
const int M=5e5+100;
long long  a[M],b[M];
long long  n,num,B,l[M],r[M],lazy[M],belong[M],youxu[M],m;
void build()
{
    B=sqrt(n);
    num=n/B;
    if(n%B)num++;
    for(int i=1; i<=num; i++)
    {
        l[i]=B*(i-1)+1;
        r[i]=B*i;
    }
    r[num]=n;
    for(int i=1; i<=num; i++)
    {
        lazy[i]=0;
        youxu[i]=0;
        for(int j=l[i]; j<=r[i]; j++)
        {
            scanf("%lld",&a[j]);
            b[j]=a[j];
            belong[j]=i;
        }
    }
}
void pushdown(int i)
{
    if(lazy[i]!=0)
    {
        for(int j=l[i]; j<=r[i]; j++)
        {
            // a[j]+=lazy[i];
            b[j]+=lazy[i];
        }
        lazy[i]=0;
    }
}
void update(int st,int ed,long long x)
{
    if(belong[st]==belong[ed]) //如果在一个区间内暴力更新
    {
        if(lazy[belong[st]])
            pushdown(belong[st]);
        for(int i=st; i<=ed; i++)
        {
            // a[i]+=x;
            b[i]+=x;
        }
        int t=belong[st];
        youxu[t]=0;
        for(int i=l[t]; i<=r[t]; i++)
        {
            // a[i]+=x;
            a[i]=b[i];
        }
    }
    else //不在一个区间内
    {
        int b_st=belong[st];
        youxu[b_st]=0;
        pushdown(b_st);//下放lazy节点很重要很重要很重要
        for(int i=st; i<=r[b_st]; i++)
        {
            // a[i]+=x;
            b[i]+=x;
        }
        for(int i=l[b_st]; i<=r[b_st]; i++)
        {
            // a[i]+=x;
            a[i]=b[i];
        }
        for(b_st++; b_st<belong[ed]; b_st++) //对于中间被覆盖的区间lazy标记全部变为v
        {
            lazy[b_st]+=x;//被完全覆盖的区间不需要向下更新只需要更新lazy标记即可
        }
        pushdown(b_st);
        youxu[b_st]=0;
        for(int i=l[b_st]; i<=ed; i++) //对于后面这段
        {
            b[i]+=x;
        }
        for(int i=l[b_st]; i<=r[b_st]; i++)
        {
            // a[i]+=x;
            a[i]=b[i];
        }
    }

}
long long  query(long long x)
{
    int i,j,st=0,f1=0;
    for(i=1; i<=num; i++)
    {
        long long  xx=x-lazy[i];
        if(!youxu[i])
        {
            sort(a+l[i],a+r[i]+1);
            youxu[i]=1;
        }
        if(a[r[i]]>=xx&&a[l[i]]<=xx)
        {
            if(f1==0)
            {
                if(binary_search(a+l[i],a+r[i]+1,xx))
                {
                    for(int ii=l[i]; ii<=r[i]; ii++)
                    {
                        if(b[ii]==xx)
                        {
                            f1=1;
                            st=ii;
                            break;
                        }
                    }
                    break;
                }

            }
        }

    }
    if(f1==0)
        return -1;
    for(j=num; j>=i; j--)
    {
        long long xx=x-lazy[j];
        if(!youxu[j])
        {
            sort(a+l[j],a+r[j]+1);
            youxu[j]=1;
        }
        if(a[r[j]]>=xx&&a[l[j]]<=xx)
        {
           if(binary_search(a+l[j],a+r[j]+1,xx))
                {
                    for(int ii=r[j]; ii>=l[j]; ii--)
                    {
                        if(b[ii]==xx)
                        {
                            return ii-st;
                        }
                    }
                    break;
                }
            }
        }
    return 0;
}
int main()
{
    //int tt;
    while(~scanf("%lld%lld",&n,&m))
    {
        build();
        //return 0;
        long long x;
        int st,ed,op;
        while(m--)
        {
            scanf("%d",&op);
            if(op==1)
            {
                scanf("%d%d%lld",&st,&ed,&x);
                update(st,ed,x);
                // return 0;
            }
            else
            {
                scanf("%lld",&x);
                printf("%lld\n",query(x));
                // return 0;
            }
        }
        //return 0;
    }
    return 0;
}