UESTC-1928-帆宝RMQ-分块暴力

（有任何问题欢迎留言或私聊 && 欢迎交流讨论哦

题目：传送门

 长度为n的数组，q次操作(1≤n≤105,1≤q≤5∗104)，操作1区间[L, R]所有数大小加x。操作2查询序列中数字x最右边下标和最左边下标 之差，如果不存在x则输出-1.

思路：

 用lazy数组解决整块的加法问题，对每个块记录块内数字和对应它的下标，存在结构体里面。非整块暴力加，加完rebuild该块。
 每个块按权值排序。

 查询时先解决lazy的影响。先找左下标再找右下标。
 对于左下标：从左到右遍历每个块，每个块用lower_bound找到对应数字，为了找到最小的下标，所以对于这个数值还要遍历一下，去最小下标。查找右下标同理。

AC代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<ctime>
#include<vector>
#include<cctype>
#include<string>
#include<cmath>
#include<bitset>
#include<cassert>
#define fuck(x) cout<<"* "<<x<<"\n"
using namespace std;
typedef long long LL;
const int N = 100007;
const int INF = 0x3f3f3f3f;
const int mod = 1e9+7;
int n,m;
int ar[N],l[N],r[N],belong[N],lazy[N];
int block,num;
struct lp{
    int x,id;
}cw[N];
vector<lp>B[1000];
bool cmp(const lp &a,const lp &b){
    if(a.x==b.x)return a.id<b.id;
    return a.x<b.x;
}
inline void build(){
    memset(lazy,0,sizeof(lazy));
    block=sqrt(n);
    num=n/block;if(n%block)num++;
    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<=n;++i){
        belong[i]=(i-1)/block+1;
    }
    for(int i=0;i<=num;++i){
        B[i].clear();
    }
    for(int i=1;i<=n;++i){
        B[belong[i]].push_back(cw[i]);
    }
    for(int i=1;i<=num;++i){
        sort(B[i].begin(), B[i].end(),cmp);
    }
}
inline void rebuild(int x){
    B[x].clear();
    for(int i=l[x];i<=r[x];++i){
        B[x].push_back(cw[i]);
    }
    sort(B[x].begin(), B[x].end(),cmp);
}
inline void add(int x,int y,int k){
    if(belong[x]==belong[y]){
        for(int i=x;i<=y;++i){
            cw[i].x+=k;
        }
        rebuild(belong[x]);
        return;
    }
    for(int i=belong[x]+1;i<belong[y];++i){
        lazy[i]+=k;
    }
    if(x==l[belong[x]]){
        lazy[belong[x]]+=k;
    }else{
        for(int i=x;i<=r[belong[x]];++i){
            cw[i].x+=k;
        }
        rebuild(belong[x]);
    }
    if(y==r[belong[y]]){
        lazy[belong[y]]+=k;
    }else{
        for(int i=l[belong[y]];i<=y;++i){
            cw[i].x+=k;
        }
        rebuild(belong[y]);
    }
}
inline void Find(int x){
    lp tmp;
    tmp.x=x;tmp.id=0;
    int L=INF,R=-1;
    int flag_l=0,flag_r=0;
    for(int i=1;i<=num;++i){
        tmp.x=x-lazy[i];
        int p=lower_bound(B[i].begin(),B[i].end(),tmp,cmp)-B[i].begin();
        int len=B[i].size();
        while(p<len&&B[i][p].x==tmp.x){
            L=min(L,B[i][p].id);
            flag_l=1;
            p++;
        }
        if(flag_l)break;
    }
    for(int i=num;i>=1;--i){
        tmp.x=x-lazy[i];
        int len=B[i].size();
        int p=lower_bound(B[i].begin(),B[i].end(),tmp,cmp)-B[i].begin();
        while(p<len&&B[i][p].x==tmp.x){
            R=max(R,B[i][p].id);
            flag_r=1;
            p++;
        }
        if(flag_r)break;
    }
    if(flag_l==0||flag_r==0)printf("-1\n");
    else{
        printf("%d\n",R-L );
    }
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        for(int i=1;i<=n;++i){
            scanf("%d",&ar[i]);
            cw[i].x=ar[i];cw[i].id=i;
        }
        build();
        while(m--){
            int op,l,r,x;
            scanf("%d",&op);
            if(op==1){
                scanf("%d%d%d",&l,&r,&x);
                add(l,r,x);
            }else{
                scanf("%d",&x);
                Find(x);
            }
        }
    }
    return 0;
}

题目描述：

帆宝在某天学习RMQ(Range Minimum/Maximum Query)的过程中突然顿悟领悟RMQ的精髓，发明了带修改RMQ，简称帆宝RMQ，复杂度极其优越。ZinYY想要学习帆宝RMQ，可是他太弱了，甚至连帆宝RBQ也学不会，所以帆宝只能教给他最简单的帆宝RQ(Range Query)

这里定义帆宝RQ为RQ(x)，表示数列中最左边x与最右边x的下标之差的绝对值，当数列中不存在x时RQ(x)=−1
帆宝讲解完算法并留下一道课堂练习题给ZinYY:对于一个长度为n的给定数列a，有q个询问，每种询问有两个类型，类型1是将区间[l,r]的数都加上x,类型2是询问RQ(x)，并将答案输出

ZinYY听完课还是一脸蒙蔽，你能帮他解决这道课堂练习题吗

Input
第一行包含两个数n,q，1≤n≤105,1≤q≤5∗104
第二行包含n个数a1,a2…an，为数列a,1≤ai≤109
接下来q行，每行有4个数或者2个数

如果一行以1开始，代表类型,输入格式为1,l,r,x,1≤l≤r≤n,0≤x≤109
如果一行以2开始，代表类型,输入格式为2,x,1≤x≤109
Output
对于每个类型2,输出RQ(x)的值

Sample input and output
Sample Input Sample Output
4 3
1 2 3 4
1 1 2 1
1 1 1 1
2 3
2
2 3
1 2
1 2 2 1
2 3
2 4
0
-1
Source
2018 UESTC Training for Data Structures