数据结构2 静态区间第K大/第K小

给定数组$A[1...N]$, 区间$[L,R]$中第$K$大/小的数的指将$A[L...R]$中的数从大到小/从小到大排序后的第$K$个.

"静态"指的是不带修改.

这个问题有多种做法:

1. 归并排序

POJ 2104, 静态区间第K小

 #include <bits/stdc++.h>
 using namespace std;

 const int N(1e5+);
 int a[][N];

 void merge(int id, int b, int e){
     int mid=(b+e)>>;
     for(int l=b, r=mid, i=b; i<e; i++){
         if(l==mid) a[id][i]=a[id+][r++];
         else if(r==e) a[id][i]=a[id+][l++];
         else if(a[id+][l]<=a[id+][r]) a[id][i]=a[id+][l++];
         else a[id][i]=a[id+][r++];
     }
 }

 void build(int id, int b, int e){
     if(b+==e){
         scanf("%d", a[id]+b);
         return;
     }
     int mid=(b+e)>>;
     build(id+, b, mid);
     build(id+, mid, e);
     merge(id, b, e);
 }
 //返回k在[l, r)与[L, R)交集上的Rank
 int Rank(int id, int L, int R, int l, int r, int k){
     if(l<=L&&R<=r){
         return lower_bound(a[id]+L, a[id]+R, k)-a[id]-L;
     }
     int mid=(L+R)>>;
     if(r<=mid){
         return Rank(id+, L, mid, l, r, k);
     }
     if(l>=mid){
         return Rank(id+, mid, R, l, r, k);
     }
     return Rank(id+, L, mid, l, r, k)+Rank(id+, mid, R, l, r, k);
 }
 //返回(l, r]中Rank(x)>=k的最小的x
 int BS(int b, int e, int k, int n){
     int l=-1e9-, r=1e9+, mid;
     while(r-l>){
         mid=(l+r)>>;
         if(Rank(, , n, b, e, mid)>=k) r=mid;
         else l=mid;
     }
     return r;
 }
 int main(){
     int n, m; scanf("%d%d", &n, &m);
     build(, , n);
     for(int l, r, k; m--;){
         scanf("%d%d%d", &l, &r, &k), l--;
         printf("%d\n", BS(l, r, k, n)-);
     }
 }

这种做法的想法是将归并排序的过程记录下来, 这样就形成了一棵线段树, 这棵线段树的每个节点记录着它所代表的那个区间[L,R]排好序后的情形.

我们把这样的线段树称做归并排序树, 归并排序树能在$O(\log^2{N})$的复杂度内完成如下查询:

$\text{RANK}(l, r, x)$: 区间$[l,r]$内小于$x$的数的数目.

定义$\text{LEAST}(l, r, k)$为区间$[l,r]$上第$k$小的数, 则有

$\text{LEAST}(l, r, k) = \max \{x \mid \text{RANK}(l, r, x)<k\}$

因而对于询问$\text{LEAST}(l, r, x)$, 我们可以二分答案 $x$ + $\text{RANK}(l, r, x)$判断, 从而在$O(\log{M}\log^2{N})$的复杂度内完成查询, 其中$M$是元素的范围, $N$是区间总长度. 当然, 我们也可以现将数组$A[1\cdots N]$排序, 付出一个$O(N\log{N}$)的预处理复杂度, 然后便可做到单次查询$O(\log^3{N})$.

但我觉得这个复杂度还是太高了, (归并排序)这种做法应该还有优化的可能性, 有待研究.

2. 划分树