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 |
| OIER公司是一家大型专业化软件公司，有着数以万计的员工。作为一名出纳员，我的任务之一便是统计每位员工的工资。这本来是一份不错的工作，但是令人郁闷的是，我们的老板反复无常，经常调整员工的工资。如果他心情好，就可能把每位员工的工资加上一个相同的量。反之，如果心情不好，就可能把他们的工资扣除一个相同的量。我真不知道除了调工资他还做什么其它事情。 工资的频繁调整很让员工反感，尤其是集体扣除工资的时候，一旦某位员工发现自己的工资已经低于了合同规定的工资下界，他就会立刻气愤地离开公司，并且再也不会回来了。每位员工的工资下界都是统一规定的。每当一个人离开公司，我就要从电脑中把他的工资档案删去，同样，每当公司招聘了一位新员工，我就得为他新建一个工资档案。 老板经常到我这边来询问工资情况，他并不问具体某位员工的工资情况，而是问现在工资第k多的员工拿多少工资。每当这时，我就不得不对数万个员工进行一次漫长的排序，然后告诉他答案。 好了，现在你已经对我的工作了解不少了。正如你猜的那样，我想请你编一个工资统计程序。怎么样，不是很困难吧？ 输入文件 第一行有两个非负整数n和min。n表示下面有多少条命令，min表示工资下界。 接下来的n行，每行表示一条命令。命令可以是以下四种之一：
在初始时，可以认为公司里一个员工也没有。 本题有多组输入。 输出文件 输出文件的行数为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约定
|
/*
* =====================================================================================
*
* 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 <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
int delta;
const int INF = 10000000;
template<typename T>
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<int> 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;
}