hust 1007 平衡树

 思路：该题目要求在log(n)时间内进行插入，删除，求后继操作，可以使用平衡树解决，由于不用求名次或者取k大，所以可以和使用stl set来解决，可以存在相同的数，所以要用multiset.

 

代码如下

1. #include <set>
2. #include <algorithm>
3. #include <iostream>
4. using namespace std;
6. int main()
7. {
8.     int i,j,k,t;
9.     int n, q, y;
10.     
11.     scanf("%d", &t);
12.     for(k = 1; k <= t; k++)
13.     {
14.         printf("Case %d:/n", k);
15.         multiset<int> a;
16.         scanf("%d%d%d", &n, &q, &y);
17.         
18.         for(i = 0; i < n; i++)
19.         {
20.             scanf("%d", &j);
21.             a.insert(j);
22.         }
23.         set<int>::iterator low;
24.         for(i = 0; i < q; i++)
25.         {
26.             scanf("%d", &j);
27.             low = a.lower_bound(j);
28.             //printf("   %d %d/n", j, *low);
29.             if(low == a.end() || *low-j > y) puts("-1");
30.             else
31.             {
32.                 printf("%d/n", *low);
33.                 a.erase(low);
34.             }
35.         }
36.     }
37. }

 

 

为了练习的目的，再次用SBT写了一遍，思路相同

 

1. #include <algorithm> 
2. using namespace std;
4. struct sbt_node
5. {
6.     int key,sz;
7.     sbt_node *lc, *rc;
8.     sbt_node(int x, int y);
9. }NIL=sbt_node(0,0),*nil=&NIL;
11. sbt_node::sbt_node(int x, int y=1)
12. {
13.     key=x,sz=y;
14.     lc=rc=nil;
15. }
17. typedef sbt_node *node;
18. node root;
20. void right_rotate(node &y)
21. {
22.     node x = y->lc;
23.     y->lc = x->rc;
24.     x->rc = y;
26.     x->sz = y->sz;
27.     y->sz = y->lc->sz + y->rc->sz +1;
28.     y = x;
29. }
31. void left_rotate(node &x)
32. {
33.     node y = x->rc;
34.     x->rc = y->lc;
35.     y->lc = x;
37.     y->sz = x->sz;
38.     x->sz = x->lc->sz + x->rc->sz +1;
39.     x = y;
40. }
42. void maintain(node &t, bool right_high)
43. {
44.     if(!right_high)
45.     {
46.         if(t->lc==nil)return;
47.         if(t->lc->lc->sz > t->rc->sz)
48.         {
49.             right_rotate(t);
50.         }
51.         else if(t->lc->rc->sz > t->rc->sz)
52.         {
53.             left_rotate(t->lc);
54.             right_rotate(t);
55.         }
56.         else return;
57.     }
58.     else
59.     {
60.         if(t->rc==nil)return;
61.         if(t->rc->rc->sz > t->lc->sz)
62.         {
63.             left_rotate(t);
64.         }
65.         else if(t->rc->lc->sz > t->lc->sz)
66.         {
67.             right_rotate(t->rc);
68.             left_rotate(t);
69.         }
70.         else return;
71.     }
72.     maintain(t->lc, 0);
73.     maintain(t->rc, 1);
74.     maintain(t, 0);
75.     maintain(t, 1);
76. }
78. void insert(node &t, int x)
79. {
80.     if(t==nil)
81.     {
82.         t = new sbt_node(x);
83.     }
84.     else
85.     {
86.         t->sz++;
87.         if(x < t->key) insert(t->lc, x);
88.         else insert(t->rc, x);
90.     }
91.     maintain(t, x >= t->key);
92. }
94. void del(node &t, int x)
95. {
96.     if(t==nil)return;
98.     t->sz--;
100.     if(x < t->key) del(t->lc, x);
101.     else if(x > t->key) del(t->rc, x);
102.     if(x == t->key)
103.     {
104.         if(t->lc==nil)
105.         {
106.             t = t->rc;
107.         }
108.         else if(t->rc==nil)
109.         {
110.             t = t->lc;
111.         }
112.         else
113.         {
114.             node tmp=t->rc;
115.             while(tmp->lc != nil)tmp = tmp->lc;
116.             t->key = tmp->key;
117.             del(t->rc, tmp->key);
118.         }
119.     }
120. }
122. int succ(node t, int x)
123. {
124.     if(t==nil)return -1;
125.     if(x == t->key) return x;
126.     else if(x > t->key) return succ(t->rc, x);
127.     else
128.     {
129.         int tmp=succ(t->lc,x);
130.         if(tmp == -1)
131.         {
132.             return t->key;
133.         }
134.         else return tmp;
135.     }
136. }
138. void print2(node t)
139. {
140.     if(t==nil)return;
141.     putchar('(');
142.     print2(t->lc);
143.     printf("size[%d]=%d/t", t->key, t->sz);
144.     print2(t->rc);
145.     putchar(')');
146. }
148. void print(node t)
149. {
150.     print2(t);
151.     puts("");
152. }
154. /*
155. 2
156. 10 10 10
157. 7 5 3 2 1 2 3 5 7 9
158. 1 5 5 5 5 5 5 5 5 5
160. 10 10 10
161. 1 2 3 4 5 6 7 8 9 10
162. 1 2 3 4 3 3 3 9 9 9
163. */
164. int main()
165. {
166.     int i, j, k, t;
167.     int n, q, y;
169.     scanf("%d", &t);
170.     for(k = 1; k <= t; k++)
171.     {
172.         root = nil;
174.         scanf("%d%d%d", &n, &q, &y);
175.         for(i = 0; i < n; i++)
176.         {
177.             scanf("%d", &j);
178.             insert(root, j);
179.         }
180.         printf("Case %d:/n", k);
181.         for(i = 0; i < q; i++)
182.         {
183.             scanf("%d", &j);
184.             int tmp = succ(root, j);
185.             if(tmp == -1 || tmp-j>y) puts("-1");
186.             else
187.             {
188.                 del(root, tmp);
189.                 printf("%d/n", tmp);
190.             }
191.             //print(root); 
192.         }
193.     }
194.     return 0;
195. }