POJ2104-- K-th Number（主席树静态区间第k大）

[转载]一篇还算可以的文章，关于可持久化线段树http://finaltheory.info/?p=249

无修改的区间第K大

• 我们先考虑简化的问题：我们要询问整个区间内的第K大。这样我们对值域建线段树，每个节点记录这个区间所包含的元素个数，建树和查询时的区间范围用递归参数传递，然后用二叉查找树的询问方式即可：即如果左边元素个数sum>=K，递归查找左子树第K大，否则递归查找右子树第K – sum大，直到返回叶子的值。

• 现在我们要回答对于区间[l, r]的第K大询问。如果我们能够得到一个插入原序列中[1, l – 1]元素的线段树，和一颗插入了[1, r]元素的线段树，由于线段树是开在值域上，区间长度是一定的，所以结构也必然是完全相同的，我们可以直接对这两颗线段树进行相减，得到的是相当于插入了区间[l ,r]元素的线段树。注意这里利用到的区间相减性质，实际上是用两颗不同历史版本的线段树进行相减：一颗是插入到第l-1个元素的旧树，一颗是插入到第r元素的新树。

下面是代码

 #include <cstdio>
 #include <string>
 #include <vector>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 const int maxn = 1e5+;
 int A[maxn],B[maxn],mp[maxn],C[maxn];                                  // A 为原始数组， B为离散化之后的数组
 int n,m,tot,c[maxn*],lson[maxn*],rson[maxn*];
 int build(int l,int r)
 {
     int root = tot++;
     c[root] = ;
     if (l != r)
     {
         int mid = (l + r) >> ;
         lson[root] = build(l,mid);
         rson[root] = build(mid+,r);
     }
     return root;
 }
 int update(int root,int pos,int val)
 {
     int newroot = tot++;
     int tmp = newroot;
     int l = ,r = n;
     c[newroot] = c[root] + val;
     while (l < r)
     {
         int mid = (l + r) >> ;
         if (pos <= mid)
         {
             rson[newroot] = rson[root];
             root = lson[root];
             lson[newroot] = tot++;
             newroot = lson[newroot];
             r = mid;
         }
         else
         {
             lson[newroot] = lson[root];
             root = rson[root];
             rson[newroot] = tot++;
             newroot = rson[newroot];
             l = mid + ;
         }
         c[newroot] = c[root] + val;
     }
     return tmp;
 }
 int query(int l_root,int r_root,int k)
 {
     int l = , r = n;
     while (l < r)
     {
         int mid = (l + r) >> ;
         /*if (c[lson[r_root]] - c[lson[l_root]] >= k)
         {
             l_root = rson[l_root];
             r_root = rson[r_root];
             r = mid;
         }
         else
         {
             k -= (c[rson[r_root]] - c[rson[l_root]]);
             r_root = lson[r_root];
             l_root = lson[l_root];
             l = mid + 1;
         }*/

         if (c[lson[r_root]] - c[lson[l_root]] >= k)
         {
             r = mid;
             l_root = lson[l_root];
             r_root = lson[r_root];
         }
         else
         {
             l = mid + ;
             k -=  c[lson[r_root]] - c[lson[l_root]];
             l_root = rson[l_root];
             r_root = rson[r_root];
         }
     }
     return l;
 }
 int per_root[maxn];
 int main(void)
 {
     #ifndef ONLINE_JUDGE
         freopen("in.txt","r",stdin);
     #endif
     while (~scanf ("%d%d",&n,&m))
     {
         tot = ;
         for (int i = ; i <= n; i++)
         {
             scanf ("%d",A+i);
             C[i] = A[i];
         }

         sort(A+,A+n+);
         n = unique(A + , A + n + ) - A - ;

         for (int i = ; i <= n; i++)
         {
             B[i] = lower_bound(A+,A+n+,C[i]) - A ;
             mp[B[i]] = C[i];
         }
         per_root[] = build(,n);
         for (int i = ; i <= n; i++)
         {
             per_root[i] = update(per_root[i-],B[i],);
         }
         for (int i = ; i < m; i++)
         {
             int l,r,k;
             scanf ("%d%d%d",&l,&r,&k);
             printf("%d\n",mp[query(per_root[l-],per_root[r], k)]);
         }
     }
     return ;
 }