PAT Stack (30)

转载自: http://blog.youkuaiyun.com/sinat_29278271/article/details/47291659

题目的大意是维护一个能随时返回中位数的栈，这个问题其实可以直接简化为维护一个能返回中位数同时支持插入和删除的数据结构。

因为题目中说明每个数据都在[1,100000]之间，所以很朴素的一种解法就是设立一个Count[100005]。插入n的 时候Count[n]++，删除的时候Count[n]--，查找的时候遍历数组，寻找前缀和为（size+1)/2的下标。但是10^5 本身是个比较大的数字，在多次查找之后果断超时了。

1.树状数组+二分查找

树状数组(Binary Indexed Tree(BIT))是一种能高效查找前缀和的数据结构。使用树状数组是为了能进行二分查找，原先遍历Count数组，最多的时候能遍历10^5次，运用二分查找可以将查找次数优化为lg(10^5)/lg(2)  < 15

[cpp]  view plain  copy

 

1. # include <cstdio>  
2. # include <stack>  
3. using namespace std;  
4. class BIT  
5. {  
6. private:  
7.     int *Elem;  
8.     int Size;  
9.     int lowbit(int n)  
10.     {  
11.         return n&(-n);  
12.     }  
13. public:  
14.     BIT(int size):Size(size+1)  /*想想看还是+1好了，要不申请了100的空间只能用到99感觉太奇怪了*/  
15.     {   
16.         Elem = new int[Size];  
17.         for (int i=0;i<Size;i++)/*还没试过用memset初始化，下次试试*/  
18.             Elem[i] = 0;  
19.     }  
20.     int GetSum(int right)/*[0,right]*/  
21.     {  
22.         int sum = 0;  
23.         while (right)  
24.         {  
25.             sum += Elem[right];  
26.             right -= lowbit(right);  
27.         }  
28.         return sum;  
29.     }  
30.     int GetSum(int left,int right)/*[left,right]*/  
31.     {  
32.         return GetSum(left-1) - GetSum(right);  
33.     }  
34.     void Add(int value,int index)  
35.     {  
36.         while (index < Size)  
37.         {  
38.             Elem[index] += value;  
39.             index += lowbit(index);  
40.         }   
41.     }  
42.     ~BIT()  
43.     {  
44.       delete[] Elem;  
45.     }  
46. };  
47. BIT bit(100000);  
48. int getmid(int size)  
49. {  
50.     int index = (size+1)/2;  
51.     int left = 1,right = 100000,mid;  
52.     while(left<right)  
53.     {  
54.         mid = (left+right)/2;  
55.         if(bit.GetSum(mid)<index)  
56.             left = mid+1;  
57.         else  
58.             right = mid;  
59.     }  
60.     return left;  
61. }  
62. int main()  
63. {  
64.   int n,tmp;  
65.   scanf("%d",&n);  
66.   stack<int> s;  
67.   char str[10];  
68.   while (n--)  
69.   {  
70.       scanf("%s",str);  
71.       switch(str[1])  
72.       {  
73.           case 'e':  
74.               {  
75.               if (s.empty())   
76.                   printf("Invalid\n");  
77.               else   
78.                   printf("%d\n",getmid(s.size()));  
79.               break;  
80.               }  
81.           case 'o':  
82.               {  
83.               if (s.empty())  
84.                   printf("Invalid\n");  
85.               else   
86.                   {  
87.                   tmp = s.top();s.pop();  
88.                   printf("%d\n",tmp);  
89.                   bit.Add(-1,tmp);  
90.                   }  
91.               break;  
92.               }  
93.           case 'u':  
94.               {  
95.                   scanf("%d",&tmp);s.push(tmp);  
96.                   bit.Add(1,tmp);  
97.               }  
98.               break;  
99.       }  
100.   }  
101.   return 0;  
102. } 

2.分桶法（分治，分层HASH，平方分割）

分桶法的基本思路是分治，在一开始的暴力解法中，我们可以认为Count数组是一个大的桶，这个大的桶里有5*10^5个小桶，每个小桶能装一个数，在分桶法中，我们建立多个大桶，每个桶中又有小桶，比如，我们建立多个500个大桶，每个桶的容量是100，同时记录每个大桶中存放的数据的个数，在查找的时候我们可以通过每个大桶中元素的快速定位到放置中位数的那个小桶。当然你可以认为这是一种HASH，hash(key) = key/10。设每个大桶中含有k个小桶，共有m个大桶，m*k = n为定值。则一开始我们需要遍历大小为m的大桶数组，后来要遍历大小为k的单个大桶，时间复杂度为O（max(k,m))在n*k为定值的情况下，易知m = k = （m*k）^(1/2)的时候效率最高为n^(1/2)。

     本题中为了方便，采用分层hash的策略，将值为key的元素放入bucke[k/100][k%100]中。

[cpp]  view plain  copy

 

1. # include <cstdio>  
2. # include <stack>  
3. using namespace std;  
4.   
5. const int _size = 100000;  
6. const int capi  = 500;  
7. int bucket[_size/capi][capi];  
8. int count[_size/capi];  
9. int getmid(int size)  
10. {  
11.     int ind = (size+1)/2,cnt=0,i,j;  
12.     for (i=0;i<_size/capi;i++)  
13.         {  
14.         if (cnt + count[i]>=ind)  
15.             break;  
16.         cnt += count[i];  
17.         }  
18.     for (j=0;j<capi;j++)  
19.         {  
20.         cnt += bucket[i][j];  
21.         if (cnt>=ind)  
22.             return j+i*capi;  
23.         }  
24.       
25. }  
26. char str[10];  
27. int main()  
28. {  
29.   int n,tmp;  
30.   scanf("%d",&n);  
31.   stack<int> s;  
32.   while (n--)  
33.   {  
34.       scanf("%s",str);  
35.       switch(str[1])  
36.       {  
37.           case 'e':  
38.               {  
39.               if (s.empty())   
40.                   printf("Invalid\n");  
41.               else   
42.                   printf("%d\n",getmid(s.size())+1);  
43.               break;  
44.               }  
45.           case 'o':  
46.               {  
47.               if (s.empty())  
48.                   printf("Invalid\n");  
49.               else   
50.                   {  
51.                   tmp = s.top();s.pop();  
52.                   printf("%d\n",tmp);  
53.                   tmp--;  
54.                   bucket[tmp/capi][tmp%capi]--;  
55.                   count[tmp/capi]--;  
56.                   }  
57.               break;  
58.               }  
59.           case 'u':  
60.               {  
61.                   scanf("%d",&tmp);s.push(tmp);  
62.                   tmp--;  
63.                   bucket[tmp/capi][tmp%capi]++;  
64.                   count[tmp/capi]++;  
65.               }  
66.               break;  
67.       }  
68.   }  
69.   return 0;  
70. }  
71. 
    

1.这个方法和树状数组+二分的方法并无矛盾，你同样可以用树状数组优化大桶元素的前缀和。

2.还有就是如果你乐意你完全可以多分几个层玩,比如key放在bucket[...][...][...]分层分多了以后，你会发现这个桶变成了一棵树，如果你分层的依据是二分法你出了一棵线段树。

3.如果数据范围增大，你可以修改hash使其映射到更小的空间，同时将每个大桶改为vector<int>数组，查询是对每个vector<int>中的元素排序，个人感觉不会很慢

3.线段树（分治）有种杀鸡用牛刀的感觉

线段树是个霸气的数据结构，基本上包含了分桶法和树状数组的全部功能。线段树的基础思想是分治，但是时间 复杂度上比分桶法更加高效，能将时间优化到O（lgn）然而在PAT的小数据之下，普通的线段树因为常数上的差距花 费的时间更长。具体的树的创建我就不说了，这里采用一点zkw线段树的思想，直接找到树的叶子自底向上走到树根，每个节点维护一个Cnt记录经过这里的路径的个数，查找中位数的时候根据每个节点的Cnt进入合适的子树进行查找。

[cpp]  view plain  copy

 

1. # include <cstdio>  
2. # include <stack>  
3. using namespace std;  
4.   
5. typedef int Node;  
6. class zkw_segtree  
7. {  
8. private:  
9.     Node *T;  
10.     int size;  
11. public:  
12.     zkw_segtree(int range)  
13.     {  
14.         for (size = 1;size < range+2;size<<=1);  
15.         T = new Node[2*size];  
16.         for (int i=1;i<size+size;i++)  
17.             T[i] = 0;      
18.     }   
19.     void Add(int value,int i)  
20.     {  
21.         for (i+=size;i;i>>=1)  
22.             T[i] += value;  
23.     }  
24.     int Query(int s,int t)  
25.     {  
26.         int ret = 0;  
27.         for (s+=size-1,t+=size+1;s^t^1;s>>=1,t>>=1)  
28.             {  
29.               if (~s^1) ret += T[s^1];  
30.               if (t^1)  ret += T[t^1];   
31.             }  
32.         return ret;  
33.     }  
34.     int Find_Kth(int k,int root = 1)  
35.     {  
36.         while (root<<1 < size<<1)  
37.         {  
38.           if (T[root<<1]>=k)  root = root<<1;  
39.           else   
40.             {  
41.               k -= T[root<<1];  
42.               root = (root<<1) + 1;  
43.             }  
44.         }             
45.         return root - size;  
46.     }  
47.     ~zkw_segtree()  
48.     {  
49.         delete[] T;  
50.     }  
51. };  
52. zkw_segtree segtree(100000);  
53. int main()  
54. {  
55.   int n,tmp;  
56.   scanf("%d",&n);  
57.   stack<int> s;  
58.   char str[10];  
59.   while (n--)  
60.   {  
61.       scanf("%s",str);  
62.       switch(str[1])  
63.       {  
64.           case 'e':  
65.               {  
66.               if (s.empty())   
67.                   printf("Invalid\n");  
68.               else   
69.                   printf("%d\n",segtree.Find_Kth((s.size()+1)/2));  
70.               break;  
71.               }  
72.           case 'o':  
73.               {  
74.               if (s.empty())  
75.                   printf("Invalid\n");  
76.               else   
77.                   {  
78.                   tmp = s.top();s.pop();  
79.                   printf("%d\n",tmp);  
80.                   segtree.Add(-1,tmp);  
81.                   }  
82.               break;  
83.               }  
84.           case 'u':  
85.               {  
86.                   scanf("%d",&tmp);s.push(tmp);  
87.                   segtree.Add(1,tmp);  
88.               }  
89.               break;  
90.       }  
91.   }  
92.   return 0;  
93. }  

4.Prioriry Queue On Multiset(红黑树是支持插入与删除的堆)真正的牛刀

讲了那么多终于讲到最终的解法了，前三种方法归根结底是利用了输入数据范围有限这一条件，要想完美解决这一问题，我们不得不借助插入查找删除效率都为O（lgn）的高级搜索树。有一种利用堆查找第K个元素的算法，维持一个大顶堆，一个小顶堆，将K个元素压入小顶堆，其余压入大顶堆，随后如果大顶堆的堆顶元素大于小顶堆的堆顶元素，就将将两个堆得元素弹出并压入另一个堆中，直到大顶堆的堆顶元素小于小顶堆的堆顶元素。这样小顶堆的堆顶元素就是第K个元素。

       

  然而对于这道题，这种算法并没有什么用处，这道题要求随时删除某一个元素，然而堆并不具备这种功能（废话，能随意删除某个元素还叫堆吗）。。

        犹记得当初学数据结构的时候，是先教的高级搜索树，后教的优先队列。老师在教优先队列的时候，为了引出堆，说，其实想要实现优先队列，用高级搜索树是完全可以的，但高级搜索树实在是太强大了，实现也比较复杂，我们需要一种更简单高效的数据结构去实现优先队列。

    于是传说中的堆诞生了，因为堆在结构上的特点，我们也无法做到随意删除其中的某个元素。

    然而此时我们需要一个能删除任意元素的优先队列，OK，是时候启动最终形态了，优先级队列超进化，红黑优先级队列。以上文字过于中二，请谨慎阅读。

    从时间复杂度上分析，插入查找和删除都是O（lgn）这里的n是指总元素的个数。

    然后，估计大家都知道要怎么做了，下面是代码，为了简单起见，并没有扩展出寻找第K个数的功能，而是直接寻找中位数。
以下是代码

[cpp]  view plain  copy

 

1. # include <cstdio>  
2. # include <stack>  
3. # include <set>  
4. using namespace std;  
5.   
6. const int debug = 1;  
7. typedef int T;  
8. class Find_Median  
9. {  
10. private:  
11.     multiset<T,greater<T> > maxheap;  
12.     multiset<T,less<T> > minheap;  
13. public:   
14.     void Push(T data)  
15.     {  
16.         if (maxheap.size() < minheap.size())   
17.             maxheap.insert(data);  
18.         else   
19.             minheap.insert(data);  
20.     }  
21.     bool Erase(T data)  
22.     {  
23.         multiset<T>::iterator it;  
24.         if ((it=maxheap.find(data))!=maxheap.end())    
25.             maxheap.erase(it);  
26.         else if ((it=minheap.find(data))!=minheap.end())   
27.             minheap.erase(it);  
28.         else   
29.             return false;  
30.         return true;  
31.     }  
32.     T Query()  
33.     {  
34.         while (maxheap.size() < minheap.size())    
35.         {  
36.             maxheap.insert(*minheap.begin());  
37.             minheap.erase(minheap.begin());  
38.         }  
39.         while (minheap.size() < maxheap.size())  
40.         {  
41.             minheap.insert(*maxheap.begin());  
42.             maxheap.erase(maxheap.begin());     
43.         }  
44.           
45.         if (maxheap.size()==0) return *minheap.begin();  
46.         if (minheap.size()==0) return *maxheap.begin();  
47.           
48.         multiset<T>::iterator maxtop = maxheap.begin();         
49.         multiset<T>::iterator mintop = minheap.begin();   
50.         while (*maxtop > *mintop)  
51.         {  
52.             maxheap.insert(*mintop);  
53.             minheap.insert(*maxtop);  
54.             maxheap.erase(maxtop);                    
55.             minheap.erase(mintop);  
56.             maxtop = maxheap.begin();   
57.             mintop = minheap.begin();   
58.         }  
59.         return *(maxheap.size() >= minheap.size()?maxtop:mintop);  
60.     }     
61. };  
62. Find_Median FM;  
63. int main()  
64. {  
65.   int n,tmp;  
66.   scanf("%d",&n);  
67.   stack<int> s;  
68.   char str[10];  
69.   while (n--)  
70.   {  
71.       scanf("%s",str);  
72.       switch(str[1])  
73.       {  
74.           case 'e':  
75.               {  
76.               if (s.empty())  printf("Invalid\n");  
77.               else   
78.                   printf("%d\n",FM.Query());  
79.               break;  
80.               }  
81.           case 'o':  
82.               {  
83.               if (s.empty())  printf("Invalid\n");  
84.               else   
85.                   {  
86.                   tmp = s.top();s.pop();  
87.                   printf("%d\n",tmp);  
88.                   FM.Erase(tmp);  
89.                   }  
90.               break;  
91.               }  
92.           case 'u':  
93.               {  
94.                   scanf("%d",&tmp);s.push(tmp);  
95.                   FM.Push(tmp);  
96.               }  
97.               break;  
98.       }  
99.   }  
100.   return 0;  
101. }  

5. 平衡搜索树——Treap（我觉得从前维护两个set求中间值是牛刀，那时我还小）

        Treap就是其中一个东西，不过主标题是平衡搜索树，就是说这道题可以使用平衡搜索树来实现，而treap只是其中一种方法。

        我们先考虑不是平衡搜索树，而是一棵普通搜索树的情况，对于每棵树我们记录这个树中总共有几个节点。

        现在记lsize是左子树的规模，rsize是右子树的规模。

        当我们需要查找第K小的数时

                如果K<=lsize，说明我们要到左子树中去查找第K大的数。

                如果K>lsize+1，说明我们要到右子树中查找第第K-(lsize+1)的数

                如果前两项不符合，说明当前节点就是我们需要寻找的第K小值，直接返回结果

        然后解释为什么要使用平衡树，不用平衡树查找时间会很长，虽然我没有试过会不会超时。

        最后安利一下Treap这个数据结构，毫无疑问是最好写的平衡二叉树，没有之一。我至今不会写红黑书，AVL树写了两次，差点把我写哭出来。但是Treap能在需要的时候随手敲出一个来。

以下是代码，虽然这段代码看起来很长，但是前头那个名片可以删除，头文件可以删除一部分，正文部分比较长是因为我出于效率考虑在单个节点中添加cnt记录重复节点的个数，这让代码变得很长，不这样做应该也是可以过的。

PS：习惯使用cin，cout的同学请小心，这道题目如果不取消cin，cout和标准输入输出流的同步，输入输出起码能用掉80ms，不要问我是怎么知道的。

[cpp]  view plain  copy

 

1. /***************************************************************** 
2.   > File Name: tmp.cpp 
3.   > Author: Uncle_Sugar 
4.   > Mail: uncle_sugar@qq.com 
5.   > Created Time: 2016年02月29日 星期一 13时28分28秒 
6.  *****************************************************************/  
7. # include <cstdio>  
8. # include <cstring>  
9. # include <cmath>  
10. # include <cstdlib>  
11. # include <climits>  
12. # include <iostream>  
13. # include <iomanip>  
14. # include <set>  
15. # include <map>  
16. # include <vector>  
17. # include <stack>  
18. # include <queue>  
19. # include <algorithm>  
20. using namespace std;  
21.   
22. const int debug = 1;  
23. const int size  = 5000 + 10;  
24. typedef long long ll;  
25.   
26. struct Treap_Node{  
27.     int value;  
28.     int fix,cnt,size;  
29.     Treap_Node *left,*right;  
30.     Treap_Node():cnt(0),size(0),left(NULL),right(NULL){}  
31.     Treap_Node(int _value):value(_value),cnt(0),size(0),left(NULL),right(NULL){}  
32. }*root = NULL;  
33. inline void Treap_SetSize(Treap_Node *&P){  
34.     if (P){  
35.         P->size = P->cnt;  
36.         if (P->left) P->size += P->left->size;  
37.         if (P->right)    P->size += P->right->size;  
38.     }  
39. }  
40. inline int lsize(Treap_Node *&P){  
41.     return P->left?P->left->size:0;  
42. }  
43. inline int rsize(Treap_Node *&P){  
44.     return P->right?P->right->size:0;  
45. }  
46. void Treap_Left_Rotate(Treap_Node *&a){  
47.     Treap_Node *b = a->right;  
48.     a->right = b->left;  
49.     b->left = a;  
50.     a = b;  
51.     Treap_SetSize(a->left);  
52.     Treap_SetSize(a->right);  
53.     Treap_SetSize(a);  
54. }  
55. void Treap_Right_Rotate(Treap_Node *&a){  
56.     Treap_Node *b = a->left;  
57.     a->left = b->right;  
58.     b->right = a;  
59.     a = b;  
60.     Treap_SetSize(a->left);  
61.     Treap_SetSize(a->right);  
62.     Treap_SetSize(a);  
63. }  
64. void Treap_Insert(Treap_Node *&P,int value){  
65.     if (!P){  
66.         P = new Treap_Node;  
67.         P->value = value;  
68.         P->fix = rand();  
69.     }  
70.     if (value < P->value){  
71.         Treap_Insert(P->left,value);  
72.         if (P->left->fix < P->fix)  
73.             Treap_Right_Rotate(P);  
74.     }  
75.     else if (P->value < value){  
76.         Treap_Insert(P->right,value);  
77.         if (P->right->fix < P->fix)  
78.             Treap_Left_Rotate(P);  
79.     }  
80.     else {  
81.         P->cnt++;  
82.     }  
83.     Treap_SetSize(P);  
84. }  
85. bool Treap_Delete(Treap_Node *&P,int value){  
86.     bool ret = false;  
87.     if (!P) {  
88.         ret = false;  
89.     }  
90.     else {  
91.         if (value < P->value)  
92.             Treap_Delete(P->left,value);  
93.         else if (P->value < value)  
94.             Treap_Delete(P->right,value);  
95.         else {  
96.             if (P->cnt==0||(--P->cnt)==0){  
97.                 if (!P->left||!P->right){  
98.                     Treap_Node *t = P;  
99.                     if (!P->right)  
100.                         P = P->left;  
101.                     else  
102.                         P = P->right;  
103.                     delete t;  
104.                     ret = true;  
105.                 }  
106.                 else if (P->left->fix < P->right->fix){  
107.                     Treap_Right_Rotate(P);  
108.                     ret = Treap_Delete(P->right,value);  
109.                 }  
110.                 else {  
111.                     Treap_Left_Rotate(P);  
112.                     ret = Treap_Delete(P->left,value);  
113.                 }  
114.             }  
115.         }  
116.         Treap_SetSize(P);  
117.     }  
118.     return ret;  
119. }  
120. Treap_Node* Treap_Findkth(Treap_Node *&P,int k){  
121.     if (k <= lsize(P))  
122.         return Treap_Findkth(P->left,k);  
123.     else if (k > lsize(P)+P->cnt)  
124.         return Treap_Findkth(P->right,k-(lsize(P)+P->cnt));  
125.     else  
126.         return P;  
127. }  
128. void Treap_Clear(Treap_Node *&root){  
129.     if (root->left)  
130.         Treap_Clear(root->left);  
131.     if (root->right)  
132.         Treap_Clear(root->right);  
133.     delete root;  
134.     root = NULL;  
135. }  
136.   
137. stack<int> stk;  
138. void push(){  
139.     int tmp;  
140.     cin >> tmp;  
141.     stk.push(tmp);  
142.     Treap_Insert(root,tmp);  
143. }  
144. void pop(){  
145.     if (stk.empty()){  
146.         cout << "Invalid\n";  
147.     }else{  
148.         cout << stk.top() << '\n';  
149.         Treap_Delete(root,stk.top());  
150.         stk.pop();  
151.     }  
152. }  
153. void peekmedian(){  
154.     if (stk.empty())  
155.         cout << "Invalid\n";  
156.     else {  
157.         Treap_Node *T = Treap_Findkth(root,(stk.size()+1)/2);  
158.         cout << T->value << '\n';  
159.     }  
160. }  
161.   
162. void InOrderTravel(Treap_Node* root){  
163.     if (root->left)  InOrderTravel(root->left);  
164.     cout << root->value << ' ' << root->cnt << '\n';  
165.     if (root->right) InOrderTravel(root->right);  
166. }  
167. int main()  
168. {  
169.     std::ios::sync_with_stdio(false);cin.tie(0);  
170.     int i,j,k;  
171.     int n;  
172.     cin >> n;  
173.     char cmd[100];  
174.     for (i=1;i<=n;i++){  
175.         cin >> cmd;  
176.         switch (cmd[1]){  
177.             case 'u':push();break;  
178.             case 'o':pop();break;  
179.             case 'e':peekmedian();break;  
180.         }  
181.     }  
182.     return 0;  
183. }