K-th Closest Distance HDU - 6621 （二分+主席树）

题目链接

题意：给定序列，给定m次询问，每次询问提供4个数l,r,p,k
查询[l,r]内和p大小相差第k小的距离数值。 (也就是相减得到的绝对值里面，第k小的数)

分析：
我们就拿上面这个例子，把数先画到坐标轴上↓

对于询问的区间[l,r]内所有的数，我们可以从0开始枚举和p的距离，同时统计当前枚举囊括的数，当某次枚举包括进了>=k个数，那么答案就找到了 。

很显然上述枚举过程可以优化成二分查找 。每次就相当于要求出询问询价内有多少个数属于[p-mid,p+mid] ，也就是需要把[l,r]区间内的数放进一个桶中用于查询。 这不就是权值线段树区间查询吗？ 并且子区间上的查询，所以需要用到主席树。建主席树维护子区间的桶即可。（其实和主席树查询子区间第k小是一样的思想）

所以我们建可持久化权值线段树（这题不需要离散化，直接动态开点就好），然后每次询问[l,r]区间的时候，就二分枚举答案，验证过程就是查询tree[r]-tree[l-1]这棵线段树里面,桶区间[p-mid,p+mid]的值。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn = 1e5+7;
const int mod = 1e9+7;
const ll inf = 34359738370;
const int INF = 1e6+5;
int n,m;
int a[maxn];
int tree[maxn*105],lc[maxn*105],rc[maxn*105],cnt=0,root[maxn];
//权值线段树 tree[rt]维护桶内元素个数,建树过程和主席树差区间第k小那题是一样的
int L,R,P,K;
void updata(int &rt,int last,int l,int r,int pos)
{
    rt=++cnt;
    tree[rt]=tree[last]+1;
    lc[rt]=lc[last],rc[rt]=rc[last];
    if(l == r) return ;
    int mid=(l+r)>>1;
    if(pos<=mid) updata(lc[rt],lc[last],l,mid,pos);
    else updata(rc[rt],rc[last],mid+1,r,pos);
}
int query(int rt1,int rt2,int l,int r,int vl,int vr)
{
    if(vl<=l && r<=vr) return tree[rt2]-tree[rt1];
    int mid=(l+r)>>1;
    if(vr<=mid) return query(lc[rt1],lc[rt2],l,mid,vl,vr);
    else if(vl>mid) return query(rc[rt1],rc[rt2],mid+1,r,vl,vr);
    return query(lc[rt1],lc[rt2],l,mid,vl,vr)+query(rc[rt1],rc[rt2],mid+1,r,vl,vr);
}
void init()
{
    cnt=0;
    memset(tree,0,sizeof(tree));
    memset(lc,0,sizeof(lc));
    memset(rc,0,sizeof(rc));
    memset(root,0,sizeof(root));
}
int main()
{
    int T;cin>>T;
    while(T--)
    {
        init();
        scanf("%d %d",&n,&m);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",a+i);
            updata(root[i],root[i-1],1,INF,a[i]);
        }
        int ans=0;
        for(int i=1;i<=m;i++)
        {
            scanf("%d %d %d %d",&L,&R,&P,&K);
            L^=ans,R^=ans,P^=ans,K^=ans;
            //我们先想着能不能距离从0开始枚举(第k小所以从最小处开始枚举)
            //某次枚举的距离内如果正好达到了k个，那么这次的枚举就是答案
            //所以考虑可以二分这个答案
            //二分,每次判断[p-mid,p+mid]区间内数的个数是否大于等于k
            int l=0,r=INF;//答案区间[0,1e6]
            while(l<=r)
            {
                int mid=(l+r)>>1;
               int num=query(root[L-1], root[R], 1, INF, max(1, P-mid), min(P+mid, INF));
//    int num=query(root[L-1], root[R], 1, INF, P-mid,P+mid); 不手动优化查询区间的话慢1500ms左右
                if(num >= K)
                {
                    ans=mid;
                    r=mid-1;
                }
                else l=mid+1;
            }
            printf("%d\n",ans);
        }
    }
    return 0;
}