1208. [HNOI2004]宠物收养场【平衡树-splay】

Description

最近，阿Q开了一间宠物收养所。收养所提供两种服务：收养被主人遗弃的宠物和让新的主人领养这些宠物。每个领养者都希望领养到自己满意的宠物，阿Q根据领养者的要求通过他自己发明的一个特殊的公式，得出该领养者希望领养的宠物的特点值a（a是一个正整数，a<2^31），而他也给每个处在收养所的宠物一个特点值。这样他就能够很方便的处理整个领养宠物的过程了，宠物收养所总是会有两种情况发生：被遗弃的宠物过多或者是想要收养宠物的人太多，而宠物太少。 1．被遗弃的宠物过多时，假若到来一个领养者，这个领养者希望领养的宠物的特点值为a，那么它将会领养一只目前未被领养的宠物中特点值最接近a的一只宠物。（任何两只宠物的特点值都不可能是相同的，任何两个领养者的希望领养宠物的特点值也不可能是一样的）如果有两只满足要求的宠物，即存在两只宠物他们的特点值分别为a-b和a+b，那么领养者将会领养特点值为a-b的那只宠物。 2．收养宠物的人过多，假若到来一只被收养的宠物，那么哪个领养者能够领养它呢？能够领养它的领养者，是那个希望被领养宠物的特点值最接近该宠物特点值的领养者，如果该宠物的特点值为a，存在两个领养者他们希望领养宠物的特点值分别为a-b和a+b，那么特点值为a-b的那个领养者将成功领养该宠物。一个领养者领养了一个特点值为a的宠物，而它本身希望领养的宠物的特点值为b，那么这个领养者的不满意程度为abs(a-b)。【任务描述】你得到了一年当中，领养者和被收养宠物到来收养所的情况，希望你计算所有收养了宠物的领养者的不满意程度的总和。这一年初始时，收养所里面既没有宠物，也没有领养者。

Input

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

Output

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

Sample Input

5
0 2
0 4
1 3
1 2
1 5

Sample Output

3
(abs(3-2) + abs(2-4)=3，最后一个领养者没有宠物可以领养)

令人智熄……写了好久发现，敲板子敲得漏洞百出
改完板子后发现自己又读错题了……GG
裸的splay+一点小处理
判断当前是宠物多还是人多，如果人多的时候再来人就把人插入树中
再来宠物就从树中取一个出来。
当宠物多时同理

我即使被钉在棺材里，也要用腐朽的声音喊出：
辣鸡数据结构毁我青春！

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<cstdlib>
  4 #include<cstring>
  5 #define MAXN (100000+10)
  6 #define MOD (1000000)
  7 using namespace std;
  8 int Father[MAXN];
  9 int Son[MAXN][2];
 10 int Key[MAXN];//结点代表的数字
 11 int Cnt[MAXN];//结点代表数字出现次数
 12 int Size[MAXN];//子树大小（含自身）
 13 int Root,sz;
 14 int INF;
 15 
 16 void Clear(int x)//清空当前节点的数值
 17 {
 18     Son[x][0]=Son[x][1]=Key[x]=Cnt[x]=Size[x]=Father[x]=0;
 19 }
 20 
 21 int Get(int x)//0为左1为右
 22 {
 23     return (Son[Father[x]][1]==x);
 24 }
 25 
 26 void Update(int x)//更新当前点的size值（用于发生修改之后）
 27 {
 28     if (x)
 29     {
 30         Size[x]=Cnt[x];
 31         if (Son[x][0]) Size[x]+=Size[Son[x][0]];
 32         if (Son[x][1]) Size[x]+=Size[Son[x][1]];
 33     }
 34 }
 35 
 36 void Rotate(int x)
 37 {
 38     int Fa=Father[x];
 39     int Fafa=Father[Fa];
 40     int wh=Get(x);
 41     Son[Fa][wh]=Son[x][wh^1];
 42     if (Son[Fa][wh])
 43         Father[Son[Fa][wh]]=Fa;
 44     Son[x][wh^1]=Fa;
 45     Father[Fa]=x;
 46     if (Fafa)
 47         Son[Fafa][Son[Fafa][1]==Fa]=x;
 48     Father[x]=Fafa;
 49     Update(Fa);
 50     Update(x);
 51 }
 52 
 53 void Splay(int x)
 54 {
 55     for (int Fa; Fa=Father[x]; Rotate(x))
 56         if (Father[Fa])
 57             Rotate(Get(x)==Get(Fa)?Fa:x);
 58     Root=x;
 59 }
 60 
 61 void Insert(int x)
 62 {
 63     if (Root==0)
 64     {
 65         sz++;
 66         Key[sz]=x;
 67         Cnt[sz]=Size[sz]=1;
 68         Root=sz;
 69         return;
 70     }
 71     int now=Root,Fa=0;
 72     while (1)
 73     {
 74         if (Key[now]==x)
 75         {
 76             Cnt[now]++;
 77             Update(now);
 78             Splay(now);
 79             break;
 80         }
 81         Fa=now;
 82         now=Son[now][x>Key[now]];
 83         if (now==0)
 84         {
 85             sz++;
 86             Father[sz]=Fa;
 87             Son[Fa][x>Key[Fa]]=sz;
 88             Key[sz]=x;
 89             Size[sz]=Cnt[sz]=1;
 90             Update(Fa);
 91             Splay(sz);
 92             break;
 93         }
 94     }
 95 }
 96 
 97 int Find(int x)
 98 {
 99     int Ans=0,now=Root;
100     while (1)
101     {
102         if (x<Key[now])
103             now=Son[now][0];
104         else
105         {
106             Ans+=Size[Son[now][0]];
107             if (x==Key[now])
108             {
109                 Splay(now);
110                 return Ans+1;
111             }
112             Ans+=Cnt[now];
113             now=Son[now][1];
114         }
115     }
116 }
117 
118 int Pre()
119 {
120     int now=Son[Root][0];
121     while (Son[now][1]) now=Son[now][1];
122     return now;
123 }
124 
125 int Next()
126 {
127     int now=Son[Root][1];
128     while (Son[now][0]) now=Son[now][0];
129     return now;
130 }
131 
132 void Del(int x)
133 {
134     int wh=Find(x);//把这个数字转到根节点 
135     if (Cnt[Root]>1)//如果这个数值不只一个就-1就好了 
136     {
137         --Cnt[Root];
138         Update(Root);
139         return;
140     }
141     if (!Son[Root][0]&&!Son[Root][1])//如果根没儿子就说明树上只有一个点 
142     {
143         Clear(Root);
144         Root=0;
145         return;
146     }
147     if (!Son[Root][0])//如果根只有一个右儿子就把右儿子当根 
148     {
149         int Oldroot=Root;
150         Root=Son[Oldroot][1];
151         Father[Root]=0;
152         Clear(Oldroot);
153         return;
154     }
155     if (!Son[Root][1])//如果根只有一个左儿子就把左儿子当根 
156     {
157         int Oldroot=Root;
158         Root=Son[Oldroot][0];
159         Father[Root]=0;
160         Clear(Oldroot);
161         return;
162     }
163     int Oldroot=Root;//如果有两个儿子就把前驱作为新根，把右子树接到新根上 
164     int Leftbig=Pre();
165     Splay(Leftbig);
166     Son[Root][1]=Son[Oldroot][1];
167     Father[Son[Root][1]]=Root;
168     Clear(Oldroot);
169     Update(Root);
170     return;
171 }
172 
173 int main()
174 {
175     int n,x,y,Ans=0,p,Now;
176     memset(&INF,0x7f,sizeof(INF));
177     scanf("%d",&n);
178     for (int i=1;i<=n;++i)
179     {
180         scanf("%d%d",&x,&y);
181         if (Root==0)
182             Now=x;
183         if (x==Now)    
184             Insert(y);
185         else  
186         {
187             if (Root==0) continue;
188             Insert(y);
189             int pre=Key[Pre()],nxt=Key[Next()];
190             if (!pre) pre=INF;
191             if (!nxt) nxt=INF;
192             Ans=(Ans+min(abs(y-pre),abs(y-nxt)))%MOD;
193             
194             if (abs(y-pre)<=abs(y-nxt))
195                 Del(pre);
196             else
197                 Del(nxt);
198             Del(y);    
199         }
200     }
201     printf("%d",Ans);
202 }