ZOJ 题目3612 Median（SBT输出中数）

Median

Time Limit: 5 Seconds
Memory Limit: 65536 KB

The median of m numbers is after sorting them in order, the middle one number of them if
m is even or the average number of the middle 2 numbers if m is odd. You have an empty number list at first. Then you can add or remove some number from the list.

For each add or remove operation, output the median of the number in the list please.

Input

This problem has several test cases. The first line of the input is an integer
T (0<T<=100) indicates the number of test cases. The first line of each test case is an integer
n (0<n<=10000) indicates the number of operations. Each of the next
n lines is either "add x" or "remove x"(-231<=x<231) indicates the operation.

Output

For each operation of one test case:If the operation is add output the median after adding
x in a single line.If the operation is remove and the number
x is not in the list, output "Wrong!" in a single line.If the operation is
remove and the number x is in the list, output the median after deleting
x in a single line, however the list is empty output "Empty!".

Sample Input

2
7
remove 1
add 1
add 2
add 1
remove 1
remove 2
remove 1
3
add -2
remove -2
add -1

Sample Output

Wrong!
1
1.5
1
1.5
1
Empty!
-2
Empty!
-1

Hint

if the result is an integer DO NOT output decimal point.And if the result is a double number , DO NOT output trailing 0s.

很简单的一道题，，有点坑的就是要用64位，，在zoj做的少，，居然不能用__int64

ac代码

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#define INF 0xfffffff
struct s
{
int left,right,size;
long long key;
}tree[100100];
int top,root;
void left_rot(int &x)
{
int y=tree[x].right;
tree[x].right=tree[y].left;
tree[y].left=x;
tree[y].size=tree[x].size;
tree[x].size=tree[tree[x].left].size+tree[tree[x].right].size+1;
x=y;
}
void right_rot(int &x)
{
int y=tree[x].left;
tree[x].left=tree[y].right;
tree[y].right=x;
tree[y].size=tree[x].size;
tree[x].size=tree[tree[x].left].size+tree[tree[x].right].size+1;
x=y;
}
void maintain(int &x,bool flag)
{
if(flag==false)
{
if(tree[tree[tree[x].left].left].size>tree[tree[x].right].size)
right_rot(x);
else
if(tree[tree[tree[x].left].right].size>tree[tree[x].right].size)
{
left_rot(tree[x].left);
right_rot(x);
}
else
return;
}
else
{
if(tree[tree[tree[x].right].right].size>tree[tree[x].left].size)
left_rot(x);
else
if(tree[tree[tree[x].right].left].size>tree[tree[x].left].size)
{
right_rot(tree[x].right);
left_rot(x);
}
else
return;
}
maintain(tree[x].left,false);
maintain(tree[x].right,true);
maintain(x,true);
maintain(x,false);
}
void insert(int &x,long long key)
{
if(x==0)
{
x=++top;
tree[x].left=0;
tree[x].right=0;
tree[x].size=1;
tree[x].key=key;
}
else
{
tree[x].size++;
if(key<tree[x].key)
insert(tree[x].left,key);
else
insert(tree[x].right,key);
maintain(x,key>=tree[x].key);
}
}
long long remove(int &x,long long key)
{
tree[x].size--;
if(key>tree[x].key)
remove(tree[x].right,key);
else
if(key<tree[x].key)
remove(tree[x].left,key);
else
if(tree[x].left!=0&&tree[x].right==0)
{
int temp=x;
x=tree[x].left;
return temp;
}
else
if(!tree[x].left&&tree[x].right!=0)
{
int temp=x;
x=tree[x].right;
return temp;
}
else
if(!tree[x].left&&!tree[x].right)
{
int temp=x;
x=0;
return temp;
}
else
{
int temp=tree[x].right;
while(tree[temp].left)
temp=tree[temp].left;
tree[x].key=tree[temp].key;
remove(tree[x].right,tree[temp].key);
}
}
int getmin(int x)
{
while(tree[x].left)
x=tree[x].left;
return tree[x].key;
}
int getmax(int x)
{
while(tree[x].right)
x=tree[x].right;
return tree[x].key;
}
int pred(int &x,int y,int key)
{
if(x==0)
{
if(y==0)
return INF;
return tree[y].key;
}
if(key>tree[x].key)
return pred(tree[x].right,x,key);
else
return pred(tree[x].left,y,key);
}
int succ(int &x,int y,int key)
{
if(x==0)
{
if(y==0)
return INF;
return tree[y].key;
}
if(key<tree[x].key)
return succ(tree[x].left,x,key);
else
return succ(tree[x].right,y,key);
}
long  long get_max_k(int &x,long long k)
{
int r=tree[tree[x].right].size+1;
if(r==k)
return tree[x].key;
else
if(r<k)
return get_max_k(tree[x].left,k-r);
else
return get_max_k(tree[x].right,k);
}
int find(int &x,long long key)
{
if(x==0)
return 0;
if(key==tree[x].key)
return 1;
if(key<tree[x].key)
return find(tree[x].left,key);
else
return find(tree[x].right,key);
}
void output()
{
int cnt=tree[root].size;
if(cnt&1)
printf("%lld\n",get_max_k(root,cnt/2+1));
else
{
long long temp=get_max_k(root,cnt/2)+get_max_k(root,cnt/2+1);
if(temp&1)
{
printf("%.1lf\n",temp/2.0);
}
else
printf("%lld\n",temp/2);
}
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
int n;
root=top=0;
scanf("%d",&n);
int i;
for(i=0;i<n;i++)
{
char str[10];
long long x;
scanf("%s%lld",str,&x);
if(str[0]=='a')
{
insert(root,x);
output();
}
else
{
if(!find(root,x))
{
printf("Wrong!\n");
continue;
}
remove(root,x);
if(tree[root].size==0)
{
printf("Empty!\n");
continue;
}
output();
}
}
}
}