[TC-FindingFriends]Finding Friends

题目大意：
　　给定一个长度为$n(n\le10^5)$的数列$A(A_i\le10^9)$，求最小的$k$满足存在一个长度至少为$m(m\le n)$的子串，对于串中的每一个数$A_i$，都至少存在一个$A_j(i\ne j)$满足$|A_i-A_j|<k$。

思路：
　　二分答案$k$，对于每次求出每个元素$A_i$左边离$A_i$最近的满足$|A_i-A_j|<k$的$left[i]=j$，同理求出每个元素$A_j$右边离$A_i$最近的满足$|A_i-A_j|<k$的$right[i]=j$。
　　考虑分治，判断区间$[l,r]$是否是满足条件的字串。
　　若$r-l+1<m$则显然不满足条件。
　　在$[l,r]$中找到一个下标$p$满足$left[p]<l$且$right[p]>r$，则若这样的$p$存在，则包含$p$的区间一定不满足条件，递归处理$[l,p)$和$(p,r]$。若找不到这样的$p$，则该区间满足条件，$k$为合法的答案。
　　寻找$p$时，如果不是直接for而是从两端同时往里寻找，设找到的$p$两端的区间长度分别是$a$和$b$，则递归的复杂度是$O(n\log n)$（递推式$T(n)=T(a)+T(b)+\min(a,b)$）。而$left$和$right$的预处理可以用线段树实现，总的时间复杂度是$O(n\log^2 n)$。

 #include<vector>
 #include<cstdio>
 #include<climits>
 #include<algorithm>
 class FindingFriends {
     private:
         using int64=long long;
         static constexpr int N=1e5+;
         int n,m,lim,arr[N],tmp[N],left[N],right[N];
         class SegmentTree {
             #define _left <<1
             #define _right <<1|1
             private:
                 int max[N<<],min[N<<];
                 void push_up(const int &p) {
                     max[p]=std::max(max[p _left],max[p _right]);
                     min[p]=std::min(min[p _left],min[p _right]);
                 }
             public:
                 void reset() {
                     std::fill(&max[],&max[N<<],INT_MIN);
                     std::fill(&min[],&min[N<<],INT_MAX);
                 }
                 void modify(const int &p,const int &b,const int &e,const int &x,const int &y) {
                     if(b==e) {
                         max[p]=std::max(max[p],y);
                         min[p]=std::min(min[p],y);
                         return;
                     }
                     const int mid=(b+e)>>;
                     if(x<=mid) modify(p _left,b,mid,x,y);
                     if(x>mid) modify(p _right,mid+,e,x,y);
                     push_up(p);
                 }
                 int qmax(const int &p,const int &b,const int &e,const int &l,const int &r) {
                     if(b==l&&e==r) return max[p];
                     const int mid=(b+e)>>;
                     int ret=INT_MIN;
                     if(l<=mid) ret=std::max(ret,qmax(p _left,b,mid,l,std::min(mid,r)));
                     if(r>mid) ret=std::max(ret,qmax(p _right,mid+,e,std::max(mid+,l),r));
                     return ret;
                 }
                 int qmin(const int &p,const int &b,const int &e,const int &l,const int &r) {
                     if(b==l&&e==r) return min[p];
                     const int mid=(b+e)>>;
                     int ret=INT_MAX;
                     if(l<=mid) ret=std::min(ret,qmin(p _left,b,mid,l,std::min(mid,r)));
                     if(r>mid) ret=std::min(ret,qmin(p _right,mid+,e,std::max(mid+,l),r));
                     return ret;
                 }
             #undef _left
             #undef _right
         };
         SegmentTree t;
         bool check(const int &l,const int &r) {
             if(r-l+<m) return false;
             int pos=-;
             for(register int i=;l+i<=r-i;i++) {
                 if(left[l+i]<l&&right[l+i]>r) {
                     pos=l+i;
                     break;
                 }
                 if(left[r-i]<l&&right[r-i]>r) {
                     pos=r-i;
                     break;
                 }
             }
             return pos==-||check(l,pos-)||check(pos+,r);
         }
         int getlow(const int &x) const {
             return std::upper_bound(&tmp[],&tmp[tmp[]]+,x-)-tmp;
         }
         int getup(const int &x) const {
             return std::lower_bound(&tmp[],&tmp[tmp[]]+,x+)--tmp;
         }
         bool check(const int &k) {
             t.reset();
             for(register int i=;i<=n;i++) {
                 left[i]=t.qmax(,,tmp[],std::max(getlow(tmp[arr[i]]-k),),std::min(getup(tmp[arr[i]]+k),tmp[]));
                 t.modify(,,tmp[],arr[i],i);
             }
             t.reset();
             for(register int i=n;i>=;i--) {
                 right[i]=t.qmin(,,tmp[],std::max(getlow(tmp[arr[i]]-k),),std::min(getup(tmp[arr[i]]+k),tmp[]));
                 t.modify(,,tmp[],arr[i],i);
             }
             return check(,n);
         }
     public:
         int shortestDistance(const int &nn,const std::vector<int> &init,const int &a,const int &b,const int &c,const int &d,const int &mm) {
             n=nn,m=mm;
             for(register unsigned i=;i<init.size();i++) arr[i+]=init[i];
             for(register int i=init.size();i<n;i++) {
                 arr[i+]=(((int64)arr[i]*a%d+(int64)b*i%d)%d+c)%d;
             }
             lim=*std::max_element(&arr[],&arr[n]+);
             std::copy(&arr[],&arr[n]+,&tmp[]);
             std::sort(&tmp[],&tmp[n]+);
             tmp[]=std::unique(&tmp[],&tmp[n]+)-&tmp[];
             for(register int i=;i<=n;i++) {
                 arr[i]=std::lower_bound(&tmp[],&tmp[tmp[]]+,arr[i])-tmp;
             }
             int l=,r=lim;
             while(l<=r) {
                 const int mid=(l+r)/;
                 if(check(mid)) {
                     r=mid-;
                 } else {
                     l=mid+;
                 }
             }
             return r+;
         }
 };