CodeForces 765 F Souvenirs 线段树

Souvenirs

题意：给你n个数， m次询问， 对于每次一次询问， 求出询问区间内绝对值差值的最小值。

题解：先按查询的右端点从小到大sort一下，然后对于塞入一个数的时候， 就处理出所有左端点到目前位置的点， 然后查询。

首先对于一个区间 [L,now] 和 另一个区间来说 [l+1,now] 来说， 左边这个区间的ans值一定是 <= 右边这个区间的 ans 值， 因为左边这个区间包含右边这个区间， 所以对于[1,now]这个区间来说，端点值左边的区间里的ans 一定 小于右边的 ans。

然后具体操作是， 先建树， 对于每一个节点来说，都讲他包含的数都塞入这个节点， 再通过归并排序保证这些数是递增排列，并且将ans树的答案都设为INF。然后对所有的查询，离线操作， 按照右端点sort一下， 然后每次对于一个新的右端点， 我们去更新他们前面的所有左端点值， 同时我们更新前面区间的时候， 我们都先检查一下这个答案能不能更新里面的值， 如果不能就剪枝， 就剪枝， 然后如果要更新右部分区间的话，就先更新右部分，再更新左部分，因为每次更新完之后d就会变小， 所以如果先更新左边，可能会导致右边区间的答案没有更新。（d为每次更新遇到的最小的ans值， 因为是先往右边更新的， 然后更左边的区间一定包含右边的这个答案， 所以即使左边的答案能更新成小一点， 但是不能更小的时候， 更新了也没有意义， 因为会更小的答案在右边）。然后查询的时候直接查询这一段区间的答案就好了。

代码：

 #include<bits/stdc++.h>
 using namespace std;
 #define Fopen freopen("_in.txt","r",stdin); freopen("_out.txt","w",stdout);
 #define LL long long
 #define ULL unsigned LL
 #define fi first
 #define se second
 #define pb push_back
 #define lson l,m,rt<<1
 #define rson m+1,r,rt<<1|1
 #define max3(a,b,c) max(a,max(b,c))
 #define min3(a,b,c) min(a,min(b,c))
 typedef pair<int,int> pll;
 const int INF = 0x3f3f3f3f;
 const LL mod =  (int)1e9+;
 const int N = 1e5 + ;
 vector<int> vc[N<<];
 int Min[N<<];
 int a[N];
 int n;
 struct Node{
     int l, r;
     int id;
 }q[N*];
 bool cmp(Node x1, Node x2){
     return x1.r < x2.r;
 }
 void Merge(int rt){
     int i = , j = ;
     int l = rt*, r = rt*+;
     int szl = vc[l].size(), szr = vc[r].size();
     while(i < szl && j < szr){
         if(vc[l][i] < vc[r][j]) vc[rt].pb(vc[l][i]), i++;
         else vc[rt].pb(vc[r][j]), j++;
     }
     while(i < szl) vc[rt].pb(vc[l][i]), i++;
     while(j < szr) vc[rt].pb(vc[r][j]), j++;
 }
 void Build(int l, int r, int rt){
     Min[rt] = INF;
     if(l == r){
         vc[rt].pb(a[l]);
         return ;
     }
     int m = l+r >> ;
     Build(lson);
     Build(rson);
     Merge(rt);
 }
 int Query(int l, int r, int rt, int L, int R){
     if(L <= l && r <= R){
         return Min[rt];
     }
     int ret = INF, m = l+r >> ;
     if(L <= m) ret = min(ret, Query(lson,L,R));
     if(m < R) ret = min(ret, Query(rson,L,R));
     return ret;
 }
 vector<int>::iterator it;
 void Update(int l, int r, int rt, int R, int v, int &d){
     if(l == r){
         Min[rt] = min(Min[rt], abs(v-vc[rt][]));
         d = min(d, Min[rt]);
         return ;
     }
     it = lower_bound(vc[rt].begin(), vc[rt].end(), v);
     if((it == vc[rt].end() || *it-v >= d) && (it == vc[rt].begin() || v - *(--it) >= d)){
         d = min(d, Query(, n, , l, R));
         return ;
     }
     int m = l+r >> ;
     if(R > m) Update(rson,R,v,d);
     Update(lson,R,v,d);
     Min[rt] = min(Min[rt*], Min[rt*+]);
 }
 int ans[N*];
 int main(){
     scanf("%d", &n);
     for(int i = ; i <= n; i++)  scanf("%d", &a[i]);
     Build(,n,);
     int m;
     scanf("%d", &m);
     for(int i = ; i <= m; i++)  scanf("%d%d", &q[i].l, &q[i].r), q[i].id = i;
     sort(q+, q++m, cmp);
     int r = ;
     int d;
     for(int i = ; i <= m; i++){
         while(r < q[i].r) {
             d = INF;
             Update(, n, , r, a[r+], d);
             r++;
         }
         ans[ q[i].id ] = Query(, n, , q[i].l, r);
     }
     for(int i = ; i <= m; i++){
         printf("%d\n", ans[i]);
     }
     return ;
 }

765F