第k元素log(n)算法--划分树

 线段树专辑

半学期小结 »

第k元素log(n)算法--划分树

2009/11/27, 23:01

前几天学线段树,这个经典的K-th number一直没有做,关键是听别人说复杂度是log(n)^3,我对这个需要两次二分+一次查找的算法非常的不爽,于是一直拖着没搞
今天正准备着手这题的时候,发现PKU的Disscuss有人提到log(n)的算法,而且编程复杂度比log(n)^3的还小,于是对这种算法充满了憧憬,那个log(n)^3的写到一半也放弃了(其实log(n)^3的归并树算法化简了之后就是求n个有序数列的第k大数)
YY了很久之后,得到下边这个代码..关键部分已经很明白的加了的注释
完全看明白之后会发现一个非常有趣的现象,划分树逆着做就变成了归并树
(其实我也不知道这是不是hyerty大神所说的划分树,乱YY的)
画了一颗划分树对数列[1 5 2 3 6 4 7 3 0 0]进行划分,下图有助于理解(红色表示该数被分到左儿子)

划分树

^?View Code CPP

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798

#define M 100001struct Seg_Tree{    int left,right;    int mid() {        return (left + right) >> 1;    }}tt[M*4];int len;int sorted[M];int toLeft[20][M];int val[20][M]; void build(int l,int r,int d,int idx) {    tt[idx].left = l;    tt[idx].right = r;    if(tt[idx].left == tt[idx].right)    return ;    int mid = tt[idx].mid();    int lsame = mid - l + 1;//lsame表示和val_mid相等且分到左边的    for(int i = l ; i <= r ; i ++) {        if(val[d][i] < sorted[mid]) {            lsame --;//先假设左边的数(mid - l + 1)个都等于val_mid,然后把实际上小于val_mid的减去        }    }    int lpos = l;    int rpos = mid+1;    int same = 0;    for(int i = l ; i <= r ; i ++) {        if(i == l) {            toLeft[d][i] = 0;//toLeft[i]表示[ tt[idx].left , i ]区域里有多少个数分到左边        } else {            toLeft[d][i] = toLeft[d][i-1];        }        if(val[d][i] < sorted[mid]) {            toLeft[d][i] ++;            val[d+1][lpos++] = val[d][i];        } else if(val[d][i] > sorted[mid]) {            val[d+1][rpos++] = val[d][i];        } else {            if(same < lsame) {//有lsame的数是分到左边的                same ++;                toLeft[d][i] ++;                val[d+1][lpos++] = val[d][i];            } else {                val[d+1][rpos++] = val[d][i];            }        }    }    build(l,mid,d+1,LL(idx));    build(mid+1,r,d+1,RR(idx));} int query(int l,int r,int k,int d,int idx) {    if(l == r) {        return val[d][l];    }    int s;//s表示[ l , r ]有多少个分到左边    int ss;//ss表示 [tt[idx].left , l-1 ]有多少个分到左边    if(l == tt[idx].left) {        s = toLeft[d][r];        ss = 0;    } else {        s = toLeft[d][r] - toLeft[d][l-1];        ss = toLeft[d][l-1];    }    if(s >= k) {//有多于k个分到左边,显然去左儿子区间找第k个        int newl = tt[idx].left + ss;        int newr = tt[idx].left + ss + s - 1;//计算出新的映射区间        return query(newl,newr,k,d+1,LL(idx));    } else {        int mid = tt[idx].mid();        int bb = l - tt[idx].left - ss;//bb表示 [tt[idx].left , l-1 ]有多少个分到右边        int b = r - l + 1 - s;//b表示 [l , r]有多少个分到右边        int newl = mid + bb + 1;        int newr = mid + bb + b;        return query(newl,newr,k-s,d+1,RR(idx));    }} int main() {    int T;    scanf("%d",&T);    while(T --) {        int n , m;        scanf("%d%d",&n,&m);        FOR(i,1,n+1) {            scanf("%d",&val[0][i]);            sorted[i] = val[0][i];        }        sort(sorted + 1 , sorted + n + 1);        build(1,n,0,1);        while(m --) {            int l,r,k;            scanf("%d%d%d",&l,&r,&k);            printf("%d\n",query(l,r,k,0,1));        }    }    return 0;}

后记:写完后去PKU交了一下,原以为不是rank1也至少是前十,结果连1s都没跑进去...
看了数据后发现m<=5000很少
意味着 nlogn(建树常数较大) + mlngn
和 nlogn(建树常数小)+mlogn^3
前者没占多少优势...
在我们hduoj也找了一道,所幸这题m <= 100000很大
两题比较:
OJ nlog(n) + mlog(n) nlog(n) + mlog(n)^3
HDU 少于500MS 3000MS左右
PKU 1000MS左右 1000-2000MS

2010.7.23跟新
扩展:
Minimum Sum
找到区间中的中位数,然后确定绝对值只和
就是找区间[l,r]的第(l-r+2)/2个数,而求和的话在Query函数里找到kth number后递归上来后再处理一下,需要另开一个数组sum[deep][i]表示第deep层,区间[ tt[idx].Left , i]的和

我比较懒都没有解释什么,只写了个代码
这篇文章解释的很清楚,可以去看看
我的代码只是为了理解方便点写的这么麻烦,其实划分树可以写的很简洁很简洁的,有好多地方可以优化~~

标签：K-th, log(n), 划分树, 归并树, 线段树
Category: Algorithm  |  Comment (RSS)  |  Trackback

 

hdu3727Jewel(划分树+二分)

分类： 划分树 数据结构2013-10-10 12:36 84人阅读 评论(0) 收藏 举报

数据结构

题目请戳这里

题目大意：给许多操作，4类：

1，insert x，插入一个数x，x范围2^31内（题目描述有误）

2，query_1 s t k，查询范围[s,t]内第k小的数，s<=t<=len(当前数字长度)

3,query_2 x   查询x的rank，从小到大。x保证出现过

4，query_3 x，查询[1,len]第x小的数。

输出3个数，为3个询问累加和。

题目分析：由于没有删除操作，所以加入的数字序列是不变的，所以离线处理。

q1和q3其实是一个操作，查询区间第k大值问题，划分树搞。

q2的话，其实也可以通过二分转化为划分树操作。如果愿意，写棵线段树单独维护一下也是可以的，不过要离散化。为了偷懒，选择二分+划分树啦

关于划分树，其实也是基于线段树的一个数据结构，模拟归并排序的过程，不断分治。详细讲解戳这里

详情请见代码：

[cpp] view plaincopy

1. #include <iostream>  
2. #include<cstdio>  
3. #include<cstring>  
4. #include<algorithm>  
5. using namespace std;  
6. const int N = 100005;  
7. const int M = 110005;  
8. const int DEEP = 20;  
9. typedef __int64 ll;  
10. ll ans[3];  
11. struct node  
12. {  
13.     int optype;  
14.     int a,b,c;  
15. }op[M];  
16. int n,m;  
17. char str[20];  
18. int num[DEEP][N],lefta[DEEP][N],lcm[N];  
19.   
20. void build(int s,int e,int nm,int dp)  
21. {  
22.     if(s == e)  
23.         return;  
24.     int mid = (s + e)>>1;  
25.     int lsame = mid - s + 1;  
26.     int i,same = 0;  
27.     for(i = s;i <= e;i ++)  
28.         if(num[dp][i] < lcm[mid])  
29.             lsame --;  
30.     int lpos = s,rpos = mid + 1;  
31.     for(i = s;i <= e;i ++)  
32.     {  
33.         if(i == s)  
34.             lefta[dp][i] = 0;  
35.         else  
36.             lefta[dp][i] = lefta[dp][i - 1];  
37.         if(num[dp][i] < lcm[mid])  
38.         {  
39.             lefta[dp][i] ++;  
40.             num[dp + 1][lpos ++] = num[dp][i];  
41.         }  
42.         else  
43.         {  
44.             if(num[dp][i] > lcm[mid])  
45.                 num[dp + 1][rpos ++] = num[dp][i];  
46.             else  
47.             {  
48.                 if(same < lsame)  
49.                 {  
50.                     same ++;  
51.                     lefta[dp][i] ++;  
52.                     num[dp + 1][lpos ++] = num[dp][i];  
53.                 }  
54.                 else  
55.                     num[dp + 1][rpos ++] = num[dp][i];  
56.             }  
57.         }  
58.     }  
59.     build(s,mid,nm<<1,dp + 1);  
60.     build(mid + 1,e,nm<<1|1,dp + 1);  
61. }  
62. int query(int s,int e,int nm,int dp,int l,int r,int k)  
63. {  
64.     if(s == e)  
65.         return num[dp][s];  
66.     int mid = (s + e)>>1;  
67.     int sa,sb;  
68.     if(s == l)  
69.         sb = 0;  
70.     else  
71.         sb = lefta[dp][l - 1];  
72.     sa = lefta[dp][r] - sb;  
73.     if(sa >= k)  
74.     {  
75.         int newl = s + sb;  
76.         int newr = s + sb + sa - 1;  
77.         return query(s,mid,nm<<1,dp + 1,newl,newr,k);  
78.     }  
79.     else  
80.     {  
81.         int bb = l - s - sb;  
82.         int b = r - l + 1 - sa;  
83.         int newl = mid + bb + 1;  
84.         int newr = mid + bb + b;  
85.         return query(mid + 1,e,nm<<1|1,dp + 1,newl,newr,k - sa);  
86.     }  
87. }  
88. ll getans1(int a,int b,int c)  
89. {  
90.     int mid,la,ra;  
91.     la = a;ra = b;  
92.     while(la <= ra)  
93.     {  
94.         mid = (la + ra)>>1;  
95.         int tmp = query(1,n,1,0,a,b,mid);  
96.         if(tmp == c)  
97.             return mid - a + 1;  
98.         else if(tmp > c)  
99.                 ra = mid - 1;  
100.             else  
101.                 la = mid + 1;  
102.     }  
103. }  
104. int main()  
105. {  
106.     int i;  
107.     int t,q,a,b,c,cas = 0;  
108.     while(~scanf("%d",&q))  
109.     {  
110.         n = m = 1;  
111.         while(q --)  
112.         {  
113.             scanf("%s",str);  
114.             if(str[0] == 'I')  
115.             {  
116.                 scanf("%d",&lcm[n]);  
117.                 num[0][n] = lcm[n ++];  
118.             }  
119.             else  
120.             {  
121.                 if(str[strlen(str) - 1] == '1')  
122.                 {  
123.                     scanf("%d%d%d",&a,&b,&c);  
124.                     op[m].optype = 0;  
125.                     op[m].a = a;op[m].b = b;op[m ++].c = c;  
126.                 }  
127.                 else if(str[strlen(str) - 1] == '2')  
128.                     {  
129.                         scanf("%d",&a);  
130.                         op[m].optype = 1;  
131.                         op[m].a = 1;op[m].b = n - 1;  
132.                         op[m ++].c = a;  
133.                     }  
134.                     else  
135.                     {  
136.                         scanf("%d",&a);  
137.                         op[m].optype = 2;  
138.                         op[m].a = 1;op[m].b = n - 1;  
139.                         op[m ++].c = a;  
140.                     }  
141.             }  
142.         }  
143.         sort(lcm + 1,lcm + n);  
144.         n --;  
145.         build(1,n,1,0);  
146.         ans[1] = ans[0] = ans[2] = 0;  
147.         for(i = 1;i < m;i ++)  
148.         {  
149.             if(op[i].optype == 1)  
150.             {  
151.                 int tmp = getans1(op[i].a,op[i].b,op[i].c);  
152.                 ans[op[i].optype] += tmp;  
153.             }  
154.             else  
155.             {  
156.                 int tmp = query(1,n,1,0,op[i].a,op[i].b,op[i].c);  
157.                 ans[op[i].optype] += tmp;  
158.             }  
159.         }  
160.         printf("Case %d:\n%I64d\n%I64d\n%I64d\n",++cas,ans[0],ans[1],ans[2]);  
161.     }  
162.     return 0;  
163. }  
164. //265MS 15908K