[HNOI2004]宠物收养场——treap

Posted 2020-11-02 JhinLZH

凡凡开了一间宠物收养场。收养场提供两种服务：收养被主人遗弃的宠物和让新的主人领养这些宠物。

每个领养者都希望领养到自己满意的宠物，凡凡根据领养者的要求通过他自己发明的一个特殊的公式，得出该领养者希望领养的宠物的特点值a（a是一个正整数，a<2^31），而他也给每个处在收养场的宠物一个特点值。这样他就能够很方便的处理整个领养宠物的过程了，宠物收养场总是会有两种情况发生：被遗弃的宠物过多或者是想要收养宠物的人太多，而宠物太少。

被遗弃的宠物过多时，假若到来一个领养者，这个领养者希望领养的宠物的特点值为a，那么它将会领养一只目前未被领养的宠物中特点值最接近a的一只宠物。（任何两只宠物的特点值都不可能是相同的，任何两个领养者的希望领养宠物的特点值也不可能是一样的）如果有两只满足要求的宠物，即存在两只宠物他们的特点值分别为a-b和a+b，那么领养者将会领养特点值为a-b的那只宠物。

收养宠物的人过多，假若到来一只被收养的宠物，那么哪个领养者能够领养它呢？能够领养它的领养者，是那个希望被领养宠物的特点值最接近该宠物特点值的领养者，如果该宠物的特点值为a，存在两个领养者他们希望领养宠物的特点值分别为a-b和a+b，那么特点值为a-b的那个领养者将成功领养该宠物。

一个领养者领养了一个特点值为a的宠物，而它本身希望领养的宠物的特点值为b，那么这个领养者的不满意程度为abs(a-b)。

你得到了一年当中，领养者和被收养宠物到来收养所的情况，请你计算所有收养了宠物的领养者的不满意程度的总和。这一年初始时，收养所里面既没有宠物，也没有领养者。

输入格式： 

第一行为一个正整数n，n<=80000，表示一年当中来到收养场的宠物和领养者的总数。接下来的n行，按到来时间的先后顺序描述了一年当中来到收养场的宠物和领养者的情况。每行有两个正整数a, b，其中a=0表示宠物，a=1表示领养者，b表示宠物的特点值或是领养者希望领养宠物的特点值。（同一时间呆在收养所中的，要么全是宠物，要么全是领养者，这些宠物和领养者的个数不会超过10000个） 

输出格式：

仅有一个正整数，表示一年当中所有收养了宠物的领养者的不满意程度的总和mod 1000000以后的结果。

这是一道比较简单的平衡树练习题，因为在同一时间只有领养者或者宠物，所以可以只开一棵treap就可以（我为了求稳开了两棵）。

先讲一下两棵treap的做法。

一棵存领养者，另一棵存宠物。

首先，一共有两种操作，一种是来了领养者，另一种是来了宠物。

那么对于领养者有两种情况：

1.没有宠物；直接将领养者加到领养者的树上。

2.有宠物；在宠物的树上找到想要的宠物。

找宠物时要先找是否有符合的宠物，如果没有再找特点值最接近的（也就是找当前值的前驱和后继）。

对于宠物同样是这两种：

1.没有领养者；直接将宠物加到宠物的树上。

2.有领养者；在领养者的树上找到合适的领养者。

一棵树的做法和两棵树类似，只要每一次记录当前树上是宠物还是领养者就行了。

另外需要注意的是每次查找前驱和后继之后要把变量清零，还有要把根节点特点值设成最大值，因为一次查找时不一定前驱和后继都有。

  1 #include<cstdio>
  2 #include<algorithm>
  3 #include<cmath>
  4 #include<cstring>
  5 #include<iostream>
  6 #include<ctime>
  7 using namespace std;
  8 int n;
  9 int opt;
 10 int x;
 11 int size[100010][2];
 12 int rs[100010][2];
 13 int ls[100010][2];
 14 long long v[100010][2];
 15 int w[100010][2];
 16 int r[100010][2];
 17 int tot[2];
 18 int root[2];
 19 long long ans;
 20 int answer_back;
 21 int answer_front;
 22 int answer_front1;
 23 int answer_back1;
 24 void up(int x,int s)
 25 {
 26     size[x][s]=size[rs[x][s]][s]+size[ls[x][s]][s]+w[x][s];
 27 }
 28 void rturn(int &x,int s)
 29 {
 30     int t;
 31     t=ls[x][s];
 32     ls[x][s]=rs[t][s];
 33     rs[t][s]=x;
 34     size[t][s]=size[x][s];
 35     up(x,s);
 36     x=t;
 37 }
 38 void lturn(int &x,int s)
 39 {
 40     int t;
 41     t=rs[x][s];
 42     rs[x][s]=ls[t][s];
 43     ls[t][s]=x;
 44     size[t][s]=size[x][s];
 45     up(x,s);
 46     x=t;
 47 }
 48 void insert_sum(int x,int &i,int s)
 49 {
 50     if(!i)
 51     {
 52         i=++tot[s];
 53         w[i][s]=size[i][s]=1;
 54         v[i][s]=x;
 55         r[i][s]=rand();
 56         return ;
 57     }
 58     size[i][s]++;
 59     if(x==v[i][s])
 60     {
 61         w[i][s]++;
 62     }
 63     else if(x>v[i][s])
 64     {
 65         insert_sum(x,rs[i][s],s);
 66         if(r[rs[i][s]][s]<r[i][s])
 67         {
 68             lturn(i,s);
 69         }
 70     }
 71     else
 72     {
 73         insert_sum(x,ls[i][s],s);
 74         if(r[ls[i][s]][s]<r[i][s])    
 75         {
 76             rturn(i,s);
 77         }
 78     }
 79       
 80     return ;
 81 }
 82 void delete_sum(int x,int &i,int s)
 83 {
 84     if(i==0)
 85     {
 86         return ;
 87     }
 88     if(v[i][s]==x)
 89     {
 90         if(w[i][s]>1)
 91         {
 92             w[i][s]--;
 93             size[i][s]--;
 94             return ;
 95         }
 96         if((ls[i][s]*rs[i][s])==0)
 97         {
 98             i=ls[i][s]+rs[i][s];
 99         }
100         else if(r[ls[i][s]][s]<r[rs[i][s]][s])
101         {
102             rturn(i,s);
103             delete_sum(x,i,s);
104         }
105         else
106         {
107             lturn(i,s);
108             delete_sum(x,i,s);
109         }
110         return ;
111     }
112     size[i][s]--;
113     if(v[i][s]<x)
114     {
115         delete_sum(x,rs[i][s],s);
116     }
117     else
118     {
119         delete_sum(x,ls[i][s],s);
120     }
121     return ;
122 }
123 int ask_num(int x,int i,int s)
124 {
125     if(i==0)
126     {
127         return 0;
128     }
129     if(v[i][s]==x)
130     {
131         return size[ls[i][s]][s]+1;
132     }
133     if(v[i][s]<x)
134     {
135         return ask_num(x,rs[i][s],s)+size[ls[i][s]][s]+w[i][s];
136     }
137     return ask_num(x,ls[i][s],s);
138 }
139 void ask_front(int x,int i,int s)
140 {
141     if(i==0)
142     {
143         return ;
144     }
145     if(v[i][s]<x)
146     {
147         answer_front1=i;
148         ask_front(x,rs[i][s],s);
149         return ;
150     }
151     else
152     {
153         ask_front(x,ls[i][s],s);
154         return ;
155     }
156     return ;
157 }
158 void ask_back(int x,int i,int s)
159 {
160     if(i==0)
161     {
162         return ;
163     }
164     if(v[i][s]>x)
165     {
166         answer_back1=i;
167         ask_back(x,ls[i][s],s);
168         return ;
169     }
170     else
171     {
172         ask_back(x,rs[i][s],s);
173         return ;
174     }
175 }
176 int main()
177 {
178     srand(12378);
179     scanf("%d",&n);
180     v[0][0]=v[0][1]=1000000000;
181     for(int i=1;i<=n;i++)
182     {
183         answer_front1=answer_back1=0;
184         scanf("%d%d",&opt,&x);
185         if(size[root[opt^1]][opt^1]==0)
186         {
187             insert_sum(x,root[opt],opt);
188         }
189         else
190         {
191             if(v[ask_num(x,root[opt^1],opt^1)][opt^1]==x)
192             {
193                 delete_sum(x,root[opt^1],opt^1);
194             }
195             else
196             {
197                 ask_front(x,root[opt^1],opt^1);
198                 ask_back(x,root[opt^1],opt^1);
199                 answer_front=v[answer_front1][opt^1];
200                 answer_back=v[answer_back1][opt^1];
201                 if(abs(answer_back-x)==abs(answer_front-x))
202                 {
203                     ans+=abs(answer_front-x);
204                     delete_sum(answer_front,root[opt^1],opt^1);
205                 }             
206                 else if(abs(answer_back-x)>abs(answer_front-x))
207                 {
208                     ans+=abs(answer_front-x);
209                     delete_sum(answer_front,root[opt^1],opt^1);
210                 }
211                 else
212                 {
213                     ans+=abs(answer_back-x);
214                     delete_sum(answer_back,root[opt^1],opt^1);
215                 } 
216             }
217         }
218         ans%=1000000;
219     }
220     printf("%lld",ans%1000000);
221     return 0;
222 }