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"(-2³¹<=x<2³¹) 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();
			}
		}
	}
}