AVL树 郁闷的出纳员 [NOI 2004] [平衡树解法]

转自：http://www.cnblogs.com/ronaflx/archive/2010/12/27/1918136.html#commentform 

郁闷的出纳员

---

Time limit:	10sec.	Submitted:	612
Memory limit:	64M	Accepted:	162

Source:  NOI 2004

---

OIER公司是一家大型专业化软件公司，有着数以万计的员工。作为一名出纳员，我的任务之一便是统计每位员工的工资。这本来是一份不错的工作，但是令人郁闷的是，我们的老板反复无常，经常调整员工的工资。如果他心情好，就可能把每位员工的工资加上一个相同的量。反之，如果心情不好，就可能把他们的工资扣除一个相同的量。我真不知道除了调工资他还做什么其它事情。 工资的频繁调整很让员工反感，尤其是集体扣除工资的时候，一旦某位员工发现自己的工资已经低于了合同规定的工资下界，他就会立刻气愤地离开公司，并且再也不会回来了。每位员工的工资下界都是统一规定的。每当一个人离开公司，我就要从电脑中把他的工资档案删去，同样，每当公司招聘了一位新员工，我就得为他新建一个工资档案。 老板经常到我这边来询问工资情况，他并不问具体某位员工的工资情况，而是问现在工资第k多的员工拿多少工资。每当这时，我就不得不对数万个员工进行一次漫长的排序，然后告诉他答案。 好了，现在你已经对我的工作了解不少了。正如你猜的那样，我想请你编一个工资统计程序。怎么样，不是很困难吧？ 输入文件 第一行有两个非负整数n和min。n表示下面有多少条命令，min表示工资下界。 接下来的n行，每行表示一条命令。命令可以是以下四种之一： I命令(I k): 新建一个工资档案，初始工资为k。如果某员工的初始工资低于工资下界，他将立刻离开公司。 A命令(A k): 把每位员工的工资加上k S命令(S k): 把每位员工的工资扣除k F命令(F k): 查询第k多的工资 在初始时，可以认为公司里一个员工也没有。 本题有多组输入。 输出文件 输出文件的行数为F命令的条数加一。 对于每条F命令，你的程序要输出一行，仅包含一个整数，为当前工资第k多的员工所拿的工资数，如果k大于目前员工的数目，则输出-1。 输出文件的最后一行包含一个整数，为离开公司的员工的总数（直接离开而没有进入公司的不算）。 样例输入 9 10 I 60 I 70 S 50 F 2 I 30 S 15 A 5 F 1 F 2 样例输出 10 20 -1 2 约定 I命令的条数不超过100000 A命令和S命令的总条数不超过100 F命令的条数不超过100000 每次工资调整的调整量不超过1000 新员工的工资不超过100000

/*
 * =====================================================================================
 *
 *       Filename:  AVLtree.cpp
 *
 *    Description:  AVLtree with template
 *
 *        Version:  1.0
 *        Created:  2010年12月27日 09时45分44秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  ronaflx
 *        Company:  hit-acm-group
 *
 * =====================================================================================
 */

#include 
#include 
#include 
using namespace std;
int delta;
const int INF = 10000000;
template
class AVL
{
public:
    AVL()
    {
        pp = pool;
        TMP = node(0,0,NULL,NULL);
        MYNULL = &TMP;
        roof = MYNULL;
    }
    void insert(T k)
    {
        insert(roof,k);
    }

    void erase(T k)
    {
        erase(roof,k);
    }

    bool empty()
    {
        return roof == MYNULL;
    }
    int findK(int k)
    {
        if(k <= 0)
            return -INF;
        return findK(roof,k);
    }
    struct node
    {
        node *lchild,*rchild;
        T value;
        int h,size;//h表示高度,size表示以当前节点为跟的子树有多少个节点
        node() {}
        node (int h,int size,node * lchild,node *rchild)
        {
            this->size = size;
            this->h = h;
            this->lchild = lchild;
            this->rchild = rchild;
        }
    };
    node* roof;
private:
#define max(a,b) ((a) < (b) ? (b) : (a))

    static const int N = 1000000;
    node* MYNULL,TMP;
    //为了快速方便的求高度而设立的虚空节点
    node pool[N],*pp;
    int findK(node* &R,int k)
    {
        if(k == R->lchild->size + 1)
            return R->value;
        else if(k <= R->lchild->size)
            return findK(R->lchild,k);
        else if(k > R->size - R->rchild->size)
            return findK(R->rchild,k + R->rchild->size - R->size);
    }
    //旋转前维护该节点的子树的height和size，然后才能根据更新的数据，判断该树是否平衡，然后旋转
    //该函数维护了平衡树的数据域
    void fix(node* &R)
    {
        R->h = max(R->rchild->h,R->lchild->h) + 1;
        R->size = R->rchild->size + R->lchild->size + 1;
    }

    void rightsinglerotate(node* &R)//LL型旋转,单旋一次
    {
        node * lc = R->lchild;
        R->lchild = lc->rchild;
        fix(R);
        lc->rchild = R;
        R = lc;
        fix(R);
    }

    void leftsinglerotate(node* &R)//RR型旋转,单选一次
    {
        node * rc = R->rchild;
        R->rchild = rc->lchild;
        fix(R);
        rc->lchild = R;
        R = rc;
        fix(R);
    }

    void leftdoublerotate(node* &R)//RL型旋转,双旋
    {
        rightsinglerotate(R->rchild);
        leftsinglerotate(R);
    }

    void rightdoublerotate(node* &R)//LR型旋转,双旋
    {
        leftsinglerotate(R->lchild);
        rightsinglerotate(R);
    }

    void maintain(node* &R)//维护平衡
    {
        if(R->lchild != MYNULL)
        {
            if(R->lchild->lchild->h == R->rchild->h + 1)
                rightsinglerotate(R);
            else if(R->lchild->rchild->h == R->rchild->h + 1)
                rightdoublerotate(R);
        }
        if(R->rchild != MYNULL)
        {
            if(R->rchild->rchild->h == R->lchild->h + 1)
                leftsinglerotate(R);
            else if(R->rchild->lchild->h == R->lchild->h + 1)
                leftdoublerotate(R);
        }
    }

    void insert(node* &R,T value)
    {
        if(R == MYNULL)
        {
            R = mynew(value);
            return;
        }
        else if(value <= R->value)
            insert(R->lchild,value);
        else if(value > R->value)
            insert(R->rchild,value);
        fix(R);
        maintain(R);
    }
    //找到该节点后，
    //如果该节点R没有右儿子，直接删除，把他的左子树R->child接到他的父节点即可。
    //如果有右儿子，那就找到他右子树中最小的元素的节点tmp，
    //把他放到当前节点R->value = tmp->value。再以他的右子树为根递归的删除tmp->value;递归完右子树维护数据域。
    //最后在调整树使其不失衡。
    void erase(node* &R,T value)
    {
        if(R == MYNULL)
            return;
        if(R->value == value)
        {
            if(R->rchild == MYNULL)
            {
                node * tmp = R;
                R = tmp->lchild;
            }
            else
            {
                node *tmp = R->rchild;
                while(tmp->lchild != MYNULL)
                    tmp = tmp->lchild;
                R->value = tmp->value;
                erase(R->rchild,tmp->value);
                fix(R);
            }
            return;
        }
        else if(value < R->value)
            erase(R->lchild,value);
        else if(value < R->value)
            erase(R->rchild,value);
        fix(R);
        maintain(R);
    }

    node* mynew(T value)
    {
        pp->lchild = pp->rchild = MYNULL;
        pp->size = pp->h = 1;
        pp->value = value;
        return pp++;
    }
#undef max
};
AVL avltree;
int main()
{
    int n,minn;
    char cmd;
    int f,cnt = 0;//cnt离开公司的人数
    while(scanf("%d %d",&n,&minn) == 2)
    {
        delta = 0;//不包括基础工资，修改后的工资
        cnt = 0;
        while(!avltree.empty())
        {
            avltree.erase(avltree.roof->value);
        }
        for(int i = 0; i < n; i++)
        {
            scanf(" %c %d",&cmd,&f);
            if(cmd == 'I')
            {
                if(f < minn)
                    continue;
                avltree.insert(f - delta);
            }
            else if(cmd == 'A')
                delta += f;
            else if(cmd == 'F')
            {
                int tmp = avltree.findK(avltree.roof->size - f + 1);
                if(tmp == -INF)
                    printf("-1\n");
                else
                    printf("%d\n",tmp + delta);
            }
            else if(cmd == 	'S')
            {
                delta -= f;
                while(!avltree.empty())
                {
                    int tmp = avltree.findK(1);
                    tmp += delta;
                    if(tmp >= minn)
                        break;
                    else
                    {
                        cnt++;
                        avltree.erase(tmp - delta);
                    }
                }
            }
        }
        printf("%d\n",cnt);
    }
    return 0;
}