poj2104 划分树 区间K大 在线 无修改

博主sbit。。。。对于高级数据结构深感无力，然后这些东西在OI竟然烂大街了，不搞就整个人都不好了呢。

于是我勇猛的跳进了这个大坑

　　　　　　　　　　——sbit

区间K大的裸题，在线，无修改。

可以用归并树（\(O(nlog^3n)\)），也可用划分树（\(O(nlogn + mlogn)\)）。果断划分树。。。（以后再来看归并树。。。再来看。。。来看。。看。。）

划分树是个什么东西呢？为什么可以做区间k大呢？

想想平衡树做k大时是如何搞的，其实内在原理是一样的。

划分树分两个步骤：建树与询问。

1. 建树

　　划分树借鉴了快排的思想。划分树的每个节点保存了一个区间，以此区间为根节点，把区间分为左子树[left, mid]和右子树[mid + 1, right]的两个子树，保证左子树内的的值不大于根节点中中位数的值，右子树不小于之，且数值在子树中的顺序遵从在根节点中时的相对位置关系。关键之处在于，给每个数值记录一个to_left，表示从[left, i]中，被划分到左子树的值的数量，在查询中，这将起到至关的作用。对于没有相同取中位数值的元素时，只要比对大小关系来进行划分即可，但是，如果有相同取中位数值的元素时，如何处理这些元素呢？

　　method 1: 离散化。。简洁易懂，方便快捷。

　　method 2: 这个方法很巧妙，网上大多数代码（都是抄hh的，sbit也是的，羞耻play了）都使用了这个方法。参考资料1给出了详细的解释。

　　引用自参考资料1:

划分的时候还有一点需要处理：如果有多个数据相同怎么办呢？通过一种特殊的处理：尽量使左右两边平均分配相同的数。这个特殊处理是这样的：

在没分之前，先假设中位数左边的数据suppose都已经分到左边了，所以suppose=mid-left+1;然后如果真的分在左边，即if(tree[level][i]<sorted[mid])

suppose--；suppose就减一！到最后，如果suppos=1，则说明中位数左边的数都小于中位数，如果有等于中位数的，则suppose大于1。

最后分配的时候，把suppose个数，分到左边就可以了，剩下的分到右边！因为suppose的初值是mid-left+1,这样就能保证中位数左边和右边的数平衡了！

2. 询问

　　类似于平衡树求k大，利用上文求出来的to_left值，我们可以通过深入划分树的层级对k的值进行缩小，最后当区间长度等于1时，k等于1，答案只有一个——就是当前值啦！用纸画画就能明白了。

 #include <cstdio>
 #include <algorithm>
 using namespace std;
 const int maxn =  + ;
 int val[][maxn], sorted[maxn], to_left[][maxn];
 int n, m;
 void build_tree(int l, int r, int layer) {
     if(l == r) return ;
     int mid = (l + r) >> ;
     int suppose = mid - l + ;
     for(int i = l; i <= r; ++i)
         if(val[layer][i] < sorted[mid])
             --suppose;
     int rec_l = l, rec_r = mid + ;
     for(int i = l; i <= r; ++i) {
         if(i == l) {
             to_left[layer][i] = ;
         } else {
             to_left[layer][i] = to_left[layer][i - ];
         }
         if(val[layer][i] < sorted[mid]) {
             ++to_left[layer][i];
             val[layer + ][rec_l++] = val[layer][i];
         } else if(val[layer][i] > sorted[mid]) {
             val[layer + ][rec_r++] = val[layer][i];
         } else {
             if(suppose != ) {
                 --suppose;
                 ++to_left[layer][i];
                 val[layer + ][rec_l++] = val[layer][i];
             } else {
                 val[layer + ][rec_r++] = val[layer][i];
             }
         }
     }
     build_tree(l, mid, layer + );
     build_tree(mid + , r, layer + );
 }

 int query(int l, int r, int layer, int ql, int qr, int kth) {
     if(l == r) return val[layer][l];
     int s, ss;
     if(l == ql) {
         s = ;
         ss = to_left[layer][qr];
     } else {
         s = to_left[layer][ql - ];
         ss = to_left[layer][qr] - s;
     }
     int mid = (l + r) >> ;
     if(kth <= ss) {
         return query(l, mid, layer + , l + s, l + s + ss - , kth);
     }
     return query(mid + , r, layer + , mid +  + ql - s - l, mid +  + qr - l - s - ss, kth - ss);
 }

 int main() {
 #ifndef ONLINE_JUDGE
     freopen("data.in", "r", stdin); freopen("data.out", "w", stdout);
 #endif
     scanf("%d%d", &n, &m);
     for(int i = ; i <= n; ++i) {
         scanf("%d", &sorted[i]);
         val[][i] = sorted[i];
     }
     sort(sorted + , sorted + n + );
     build_tree(, n, );
     while(m--) {
         int l, r, k;
         scanf("%d%d%d", &l, &r, &k);
         printf("%d\n", query(, n, , l, r, k));
     }
     return ;
 }

参考资料：

1. http://sbp810050504.blog.51cto.com/2799422/1008930
2. http://blog.sina.com.cn/s/blog_5f5353cc0100ki2e.html
3. http://www.cppblog.com/MatoNo1/archive/2011/06/27/149604.html
4. http://www.xuebuyuan.com/829409.html
5. http://shizhixinghuo.diandian.com/post/2012-09-02/40037691896
6. http://baike.baidu.com/view/4199603.htm
7. http://barty.ws/partitiontree-%E5%88%92%E5%88%86%E6%A0%91/