最早见到这题是在07年JSOI冬令营上，当时知道了个大概，最近才弄明白，惭愧。。。

题意很简单，询问长度为100000的数组中给定区间上的第K大值

1. 考虑子问题，对于给定的数x，如何求出在给定区间上比x小的数有多少个（即x的排名）

2. 如果问题1得到解决，那么我们可以通过对排序过的原数组进行二分答案，直到找到一个数y，使得它在给定区间上的排名为K

本题使用线段树的思想（更严格的说，应该是归并树），树中每个节点（线段）保存该区间内原数值的有序序列。

例如原区间上的数为 2， 5， 3 那么，最终该区间上保存的数值是2，3，5. 其实并不需要存下这么多数，只需要保留一个索引（在有序数组中两端的位置）即可。这一步其实就是一个归并排序的过程。

对于给定一个数，我们查询其在给定区间上的排名。如果该区间正好覆盖了线段树的一个节点，那么直接进行二分查找即可。

如果不覆盖，只需要分别递归进入子区间，最终的排名即是两个子区间排名之和。

以上即是本题的基本算法。在我看来，这个题目的繁琐之处在于二分查找的部分。

第一个二分查找：

这是在二分答案的时候。举例： 如果给定区间上的数是2， 5， 10， 要求第三大

如果我们二分的答案是6，7，8，9，10，算出的排名都会是3. 这个时候我们要选最大的一个。

第二个二分查找：

这是在给定区间上二分查找排名的时候。其实就是查找比给定数值小的数的个数。这个时候如果遇上和给定数x相同的数，应当算作比x大来处理。

通过这个题目我知道了归并树的应用以及二分中一些细节的处理，这是以前不曾遇到的。

具体实现可参见我的代码：

1. #include <iostream>
2. using namespace std;
3. const int N = 100010;
4. struct node
5. {
6. int x, y;
7. int dep;
8. }seg[N<<3];
9. int sorted[18][N];
10. int n, m;
11. int readData()
12. {
13. int ret = 0;
14. char ch;
15. bool dot = false,neg = false;
16. while (((ch=getchar()) > '9' || ch < '0') && ch != '-') ;
17. if (ch == '-') {
18. neg = true;
19. ch = getchar();
20. }
21. do {
22. ret = ret*10 + (ch-'0');
23. } while ((ch=getchar()) <= '9' && ch >= '0') ;
24. return (neg? -ret : ret);
25. }
26. void build(int root, int x, int y, int depth)
27. {
28. seg[root] = (node){x, y, depth};
29. if(x != y)
30. {
31. int mid = (x + y) >> 1;
32. build(root * 2, x, mid, depth + 1);
33. build(root * 2 + 1, mid + 1, y, depth + 1);
34. int i = x, j = mid + 1, t = x;
35. while(i <= mid || j <= y)
36. {
37. if(j > y || (i <= mid && sorted[depth+1][i] <= sorted[depth+1][j]))
38. sorted[depth][t++] = sorted[depth+1][i++];
39. else sorted[depth][t++] = sorted[depth+1][j++];
40. }
41. }
42. else scanf("%d",&sorted[depth][x]);
43. }
44. int be, en, Kth;
45. int query(int root, int x)
46. {
47. if(be <= seg[root].x && en >= seg[root].y)
48. {
49. int low = seg[root].x, up = seg[root].y;
50. int d = seg[root].dep;
51. if(x <= sorted[d][low]) return 0;
52. else if(x > sorted[d][up]) return seg[root].y - seg[root].x + 1;
53. while(low < up)
54. {
55. int mid = (low + up + 1) >> 1;
56. if(sorted[d][mid] >= x) up = mid - 1;
57. else low = mid;
58. }
59. return low - seg[root].x + 1;
60. }
61. else
62. {
63. int ans = 0;
64. int mid = (seg[root].x + seg[root].y) >> 1;
65. if(be <= mid) ans += query(root * 2, x);
66. if(en > mid) ans += query(root * 2 + 1, x);
67. return ans;
68. }
69. }
70. int main()
71. {
72. int i, j;
73. n = readData(), m = readData();
74. build(1, 1, n, 0);
75. for(; m; m--)
76. {
77. be = readData(), en = readData(), Kth = readData();
78. int low = 1, up = n;
79. while(up > low)
80. {
81. int mid = (up + low + 1) >> 1;
82. if(query(1, sorted[0][mid]) >= Kth) up = mid - 1;
83. else low = mid;
84. }
85. printf("%d/n",sorted[0][low]);
86. }
87. return 0;
88. }