HDU-6621 主席树+二分优化

题目链接：HDU-6621 K-th Closest Distance

题目解析

这本来应该是多校的时候用来救命的一道数据结构水题，结果当时不知道是测评机有问题还是我代码不够简单，15s都TLE了，当时很慌，也没细想，后来重写了一遍，6s不到过了。
题意很好理解，一个数组，我问你某一子区间内所有数和$p$的差值里，第$k$小的是多少？
首先，这题主席树基本不难想，要是不会主席树可以参考我以前的博客：[数据结构——静态主席树]
关键在于这题建好主席树之后怎么办。当时标程好像是二分枚举$k$的值，然后看查询区间在$[p-k,p+k]$范围内的数个数。
我用的是另一种思路，二分枚举区间左端点。我们注意到，和$p$距离前$k$大的数在数值上一定是连续的。主席树本身就是用来查询区间第$k$大的数的，所以，我们可以枚举这段连续区间的左端点，然后+k-1就是右端点，然后比较他们各自与$p$的差值，如果二者在$p$两边且与$p$距离相等，那么此时这就是最优方案。否则，如存在更优状态，我们把与$p$距离大的一段向中心移动一定是更优的（注意先更新$x$的值再移动，因为移动不一定会带来更优解，若本来就是最优解状态，可能任何移动都会带来更差的解）。这样二分下去就是答案。
上代码：

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

const int maxn = 1e6 + 10;
int n, q, m, tot;

int a[maxn], b[maxn], T[maxn];
int ls[maxn*30], rs[maxn*30], c[maxn*30];

void init()
{
    tot = 0;
    for(int i = 1; i <= n; i++)
        b[i] = a[i];
    sort(b+1, b+1+n);
    m = unique(b+1, b+1+n) - b -1;
}

int build(int l, int r)
{
    int rt = tot++;
    c[rt] = 0;
    if(l != r){
        int mid = (l+r) >> 1;
        ls[rt] = build(l, mid);
        rs[rt] = build(mid+1, r);
    }
    return rt;
}

int update(int rt, int pos)
{
    int nw = tot++, res = nw;
    c[nw] = c[rt] + 1;
    int l = 1, r = m;
    while(l != r){
        int mid = (l+r) >> 1;
        if(pos <= mid){
            ls[nw] = tot++, rs[nw] = rs[rt];
            nw = ls[nw], rt = ls[rt];
            r = mid;
        }
        else{
            rs[nw] = tot++, ls[nw] = ls[rt];
            nw = rs[nw], rt = rs[rt];
            l = mid+1;
        }
        c[nw] = c[rt] + 1;
    }
    return res;
}

int query(int lrt, int rrt, int k)
{
    if(c[lrt] - c[rrt] +1 < k) return -1;
    int l = 1, r = m;
    while(l != r){
        int mid = (l+r) >> 1;
        if(c[ls[lrt]] - c[ls[rrt]] >= k){
            r = mid;
            lrt = ls[lrt], rrt = ls[rrt];
        }
        else{
            l = mid+1;
            k -= c[ls[lrt]] - c[ls[rrt]];
            lrt = rs[lrt], rrt = rs[rrt];
        }
    }
    return b[l];
}

void solve()
{
    int x = 0;
    scanf("%d%d", &n, &q);
    for(int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    init();
    T[n+1] = build(1, m);
    for(int i = n; i; i--){
        int pos = lower_bound(b+1, b+1+m, a[i]) - b;
        T[i] = update(T[i+1], pos);
    }
    while(q--){
        int l, r, k, p;
        scanf("%d%d%d%d", &l, &r, &p, &k);
        l ^= x, r ^= x, p ^= x, k ^= x;
        int rr = r - k +2 - l, ll = 1, mid = (ll+rr) >> 1;
        int e = query(T[l], T[r+1], 1), f = query(T[l], T[r+1], k);
        x = max(abs(e-p), abs(p-f));
        while(ll < rr){
            int e = query(T[l], T[r+1], mid), f = query(T[l], T[r+1], mid+k-1);
            x = min(x, max(abs(e-p), abs(p-f)));
            if(p-e == f-p) break;
            if(f < p || abs(p-e)>abs(f-p)) ll = mid+1, mid = (ll+rr) >> 1;
            else rr = mid, mid = (ll+rr) >> 1;
        }
        e = query(T[l], T[r+1], mid), f = query(T[l], T[r+1], mid+k-1);
        x = min(x, max(abs(e-p), abs(p-f)));
        printf("%d\n", x);
    }
}

int main()
{
    int t;
    scanf("%d", &t);
    for(int i = 0; i < t; i++)
        solve();
}