★【划分树】K-th Number

Description
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.

Input
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 109 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).

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

Sample Input
7 3
1 5 2 6 3 7 4
2 5 3
4 4 1
1 7 3

Sample Output
5
6
3

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

此题可以用划分树解决。
事先将各个数的排名预处理出来，放在ord数组中，然后层层划分下去，直到区间中只有一个数为止。
具体细节见程序。

Accode:

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>
const int maxN = 100010;
int tr[20][maxN], sumL[20][maxN];
int num[maxN], ord[maxN], n, m;

inline bool cmp(const int &a, const int &b)
{return num[a] < num[b];}

void Build(int L, int R, int D)
{
	int Mid = ((L + R) >> 1) + 1, p = 0;
	//这里将Mid+1是为了方便后面的处理，
	//p用于记录被放到左边的数的个数。
	for (int i = L; i < R + 1; ++i)
	if (tr[D][i] < Mid)
		tr[D + 1][L + p] = tr[D][i],
		sumL[D][i] = ++p;
	//如果它的排位低于Mid，那么将将其放在左边。
	else tr[D + 1][Mid + i - L - p] = tr[D][i],
		sumL[D][i] = p;
	//否则将其放在右边。
	if (p > 1) Build(L, Mid - 1, D + 1); //
	//这里一定要p > 1（左边被放入了一些数）才建左子树，否则出错。
	if (Mid < R) Build(Mid, R, D + 1);
	//这里一定要Mid < R才建右子树，否则出错！！
	return;
}

int query(int l, int r, int L, int R, int D, int k)
{
	if (l == r) return num[ord[tr[D][l]]];
	int Mid = ((l + r) >> 1) + 1,
		_L = L > l ? sumL[D][L - 1] : 0,
		//得到区间[l,L)中放入到左边的数的个数。
		_R = sumL[D][R];
	//得到区间[l,R]中放入到左边的数的个数。
	if (_R - _L >= k)
		//若区间[L,R]中放入的数不少于k，
		//那么就在左子树中询问，
		//相应的区间作一些改变。
		return query(l, Mid - 1, l + _L, l + _R - 1, D + 1, k);
	else return query(Mid, r, Mid + L - l - _L, 
			Mid + R - l - _R, D + 1, k - _R + _L);
	//否则则右子树中询问。
}

int main()
{
	freopen("k_th_num.in", "r", stdin);
	freopen("k_th_num.out", "w", stdout);
	scanf("%d%d", &n, &m);
	for (int i = 1; i < n + 1; ++i)
		scanf("%d", num + (ord[i] = i));
	std::sort(ord + 1, ord + n + 1, cmp);
	for (int i = 1; i < n + 1; ++i)
		tr[0][ord[i]] = i;
	Build(1, n, 0);
	while (m--)
	{
		int L, R, k; scanf("%d%d%d", &L, &R, &k);
		printf("%d\n", query(1, n, L, R, 0, k));
	}
	return 0;
}