PKU-2104-K-th Number

You are working for Macrohard company in data structures department. After failing your previous task about key insertion you were asked to write a new data structure that would be able to return quickly k-th order statistics in the array segment.
That is, given an array a[1...n] of different integer numbers, your program must answer a series of questions Q(i, j, k) in the form: "What would be the k-th number in a[i...j] segment, if this segment was sorted?"
For example, consider the array a = (1, 5, 2, 6, 3, 7, 4). Let the question be Q(2, 5, 3). The segment a[2...5] is (5, 2, 6, 3). If we sort this segment, we get (2, 3, 5, 6), the third number is 5, and therefore the answer to the question is 5.

The first line of the input file contains n --- the size of the array, and m --- the number of questions to answer (1 <= n <= 100 000, 1 <= m <= 5 000).
The second line contains n different integer numbers not exceeding 10⁹ by their absolute values --- the array for which the answers should be given.
The following m lines contain question descriptions, each description consists of three numbers: i, j, and k (1 <= i <= j <= n, 1 <= k <= j - i + 1) and represents the question Q(i, j, k).

For each question output the answer to it --- the k-th number in sorted a[i...j] segment.

7 3
1 5 2 6 3 7 4
2 5 3
4 4 1
1 7 3

5
6
3

This problem has huge input,so please use c-style input(scanf,printf),or you may got time limit exceed.

Northeastern Europe 2004, Northern Subregion

这道题貌似有很多种解法

我是用归并树做的

所谓归并树就是将 归并排序过程组成一个树

树上的每个节点就是非递减的。

以1 5 2 6 3 7为例：
把归并排序递归过程记录下来即是一棵归并树：
        [1 2 3 5 6 7]
    [1 2 5]      [3 6 7]
   [1 5] [2]    [3 6] [7]
  [1][5]         [6][3]
用对应的下标区间建线段树：（这里下标区间对应的是原数列）
            [1 6]
     [1 3]      [4 6]
  [1 2] [3]   [4 5][6]
  [1][2]      [4][5]

做法就是在归并树的根节点二分查找答案，然后用线段树查询rank值，因为线段树的每个节点与归并树的节点是一一对应的，而归并树的的节点元素是非递减的，因此可以用二分算出rank值。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
using namespace std;
const int maxn = 100000+10;

struct node{
    int lson,rson;
    int mid(){
        return (lson+rson)>>1;
    }
}tree[maxn*4];

int seg[25][maxn];
int n,m;
int num[maxn];
int sta,ed;

void build(int L,int R,int rt,int deep){
    tree[rt].lson = L;
    tree[rt].rson = R;
    if(L==R){
        seg[deep][L] = num[L];
        return;
    }
    int mid = tree[rt].mid();
    build(L,mid,rt<<1,deep+1);
    build(mid+1,R,rt<<1|1,deep+1);
    int i = L,j = mid+1,k = L;
    while(i <= mid && j <= R){
        if(seg[deep+1][i] < seg[deep+1][j]){
            seg[deep][k] = seg[deep+1][i];
            i++;
        }else{
            seg[deep][k] = seg[deep+1][j];
            j++;
        }
        k++;
    }
    while(i <= mid){
        seg[deep][k] = seg[deep+1][i];
        i++;
        k++;
    }
    while(j <= R){
        seg[deep][k] = seg[deep+1][j];
        j++;
        k++;
    }
    return;
}

int query(int rt,int dep,int key){
    if(tree[rt].lson >= sta && tree[rt].rson <= ed){
        int t = lower_bound(&seg[dep][tree[rt].lson],&seg[dep][tree[rt].rson]+1,key)-&seg[dep][tree[rt].lson];
        return t;
    }
    int mid = tree[rt].mid();
    int  res = 0;
    if(mid >= sta){
        res += query(rt<<1,dep+1,key);
    }
    if(mid < ed){
        res += query(rt<<1|1,dep+1,key);
    }
    return res;
}

int binary(int tk){
    int L = 1,R = n;
    while(L <= R){
        int mid = (L+R) >> 1;
        if(query(1,0,seg[0][mid]) > tk){
            R = mid-1;
        }else{
            L = mid+1;
        }
    }
    if(query(1,0,seg[0][R])==tk){
        return seg[0][R];
    }else{
        return seg[0][L];
    }
}

int main(){

    cin >> n >> m;
    for(int i = 1; i <= n; i++){
        scanf("%d",&num[i]);
    }
    build(1,n,1,0);
    while(m--){
        int k;
        scanf("%d%d%d",&sta,&ed,&k);
        printf("%d\n",binary(k-1));
    }
    return 0;
}