【平衡二叉樹】【NOI2004】郁闷的出纳员
【问题描述】 OIER公司是一家大型专业化软件公司，有着数以万计的员工。作为一名出纳员，我的任务之一便是统计每位员工的工资。这本来是一份不错的工作，但是令人郁闷的是，我们的老板反复无常，经常调整员工的工资。如果他心情好，就可能把每位员工的工资加上一个相同的量。反之，如果心情不好，就可能把他们的工资扣除一个相同的量。我真不知道除了调工资他还做什么其它事情。 工资的频繁调整很让员工反感，尤其是集体扣除工资的时候，一旦某位员工发现自己的工资已经低于了合同规定的工资下界，他就会立刻气愤地离开公司，并且再也不会回来了。每位员工的工资下界都是统一规定的。每当一个人离开公司，我就要从电脑中把他的工资档案删去，同样，每当公司招聘了一位新员工，我就得为他新建一个工资档案。 老板经常到我这边来询问工资情况，他并不问具体某位员工的工资情况，而是问现在工资第k多的员工拿多少工资。每当这时，我就不得不对数万个员工进行一次漫长的排序，然后告诉他答案。 好了，现在你已经对我的工作了解不少了。正如你猜的那样，我想请你编一个工资统计程序。怎么样，不是很困难吧？ 【输入文件】 第一行有两个非负整数n和min。n表示下面有多少条命令，min表示工资下界。 接下来的n行，每行表示一条命令。命令可以是以下四种之一： 名称 格式 作用 I命令 I_k 新建一个工资档案，初始工资为k。如果某员工的初始工资低于工资下界，他将立刻离开公司。 A命令 A_k 把每位员工的工资加上k S命令 S_k 把每位员工的工资扣除k F命令 F_k 查询第k多的工资 _（下划线）表示一个空格，I命令、A命令、S命令中的k是一个非负整数，F命令中的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第一個Size Balanced Tree(SBT)程序。
此程序中包含SBT的插入，刪除（非標準），查找第k大等操作。
使用偽鏈表的方式維護各個SBT，詳細細節見程序。
Accode：
#include <cstdio>
#include <cstdlib>
const char fi[] = "cashier.in";
const char fo[] = "cashier.out";
const int maxN = 100010;
int sz[maxN], key[maxN];
int lc[maxN], rc[maxN];
int N, Lim, T, tot, ans, delta;
void init_file()
{
freopen(fi, "r", stdin);
freopen(fo, "w", stdout);
}
inline void R_rotate(int &T)
{
int tmp = lc[T];
lc[T] = rc[tmp];
rc[tmp] = T;
sz[tmp] = sz[T];
sz[T] = sz[lc[T]] + sz[rc[T]] + 1;
T = tmp;
} //右旋。
inline void L_rotate(int &T)
{
int tmp = rc[T];
rc[T] = lc[tmp];
lc[tmp] = T;
sz[tmp] = sz[T];
sz[T] = sz[lc[T]] + sz[rc[T]] + 1;
T = tmp;
} //左旋。
inline void Maintain(int &T, bool flag)
{
if (!flag)
{
if (sz[lc[lc[T]]] > sz[rc[T]])
R_rotate(T);
else
if (sz[rc[lc[T]]] > sz[rc[T]])
{
L_rotate(lc[T]);
R_rotate(T);
}
else return;
}
else
{
if (sz[rc[rc[T]]] > sz[lc[T]])
L_rotate(T);
else
if (sz[lc[rc[T]]] > sz[lc[T]])
{
R_rotate(rc[T]);
L_rotate(T);
}
else return;
}
Maintain(lc[T], false);
Maintain(rc[T], true);
Maintain(T, false);
Maintain(T, true);
} //若flag為false，則調整因左子樹
//的插入而引起的不平衡；
//否則調整因右子樹的插入而引起的不平衡。
inline void insert(int &T, int v)
{
if (!T)
{
key[T = ++tot] = v;
lc[T] = rc[T] = 0;
sz[T] = 1;
return;
} //若該插入的子樹為空，
//則新分配空間，並插入節點。
++sz[T];
if (v < key[T]) insert(lc[T], v);
//若要插入的節點比當前節點小，
//則插入到左子樹。
else insert(rc[T], v);
//否則插入到右子樹。
Maintain(T, v >= key[T]);
//調整T使其成為SBT。
}
inline int Del(int &T)
{
if (!T) return 0;
int sum = 0;
if (key[T] + delta < Lim)
{
sum += sz[lc[T]] + 1;
//先將該節點連通左子樹一併去除。
sz[T] -= sum;
lc[T] = 0;
//左子樹置為空。
int tmp = Del(rc[T]);
//遞歸遍曆右子樹。
sum += tmp;
sz[T] -= tmp;
sz[rc[T]] = sz[T];
//T的大小標記向下傳。
T = rc[T];
//T指向右子樹。
return sum;
} //若當前節點滿足刪除要求，
//則將該節點連同左子樹一併去除，
//並遞歸遍曆右子樹看是否有可以去除的節點。
sum += Del(lc[T]);
//遞歸遍曆左子樹。
sz[T] -= sum;
return sum;
} //按條件對T這顆SBT進行檢查，
//遇到該去除的節點即去除，
//並返回去除的節點數。
inline int Select(int &T, int k)
{
if (k == sz[lc[T]] + 1) return key[T];
if (k < sz[lc[T]] + 1)
return Select(lc[T], k);
if (k > sz[lc[T]] + 1)
return Select(rc[T], k - sz[lc[T]] - 1);
}
void work()
{
scanf("%d%d", &N, &Lim);
int x;
delta = 0;
//由於題目中涉及到將所有的工資同時提高和降低，
//所以設有delta的標記，以便統計。
ans = 0;
for (; N; --N)
{
int x;
switch (getchar(), getchar())
{
case 'I':
{
scanf("%d", &x);
if (x >= Lim) insert(T, x - delta);
//這裡退出的人不算在總退出人數中。
//插入只需要維護x與delta的差值即可。
break;
}
case 'A':
{
scanf("%d", &x);
delta += x;
break;
}
case 'S':
{
scanf("%d", &x);
delta -= x;
ans += Del(T);
//檢查是否有出去的員工。
break;
}
case 'F':
{
scanf("%d", &x);
if (x > sz[T]) printf("-1\n");
//排除非法情況。
else printf("%d\n",
Select(T, sz[T] - x + 1) + delta);
break;
}
}
}
printf("%d", ans);
}
int main()
{
init_file();
work();
exit(0);
}
再贴一个用跳跃表实现的程序：
在跳跃表中，始终要注意保证最上方一条链为空，且这条空链在查找时也需要被遍历。
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
const int maxL = 100;
const int MAX = 0x3f3f3f3f;
const int MIN = ~MAX;
struct Node
{
int sum[maxL], lev, key, cnt;
//sum[i]为第i层该节点与其右边相邻
//节点之间的节点个数（区间左开右闭），
//lev为该点的层数范围（其对应区间为[0, lev)），
//key为该点的关键值，cnt为该点的频数。
Node *next[maxL];
//next[i]为第i层的后继结点。
Node() {}
Node(int key, int cnt, int lev):
key(key), cnt(cnt), lev(lev)
{
memset(sum, 0, sizeof sum);
memset(next, 0, sizeof next);
}
};
struct SkipList
{
Node *head, *tail; //跳跃表的首尾指针。
int lev; //跳跃表的高度。
SkipList(): lev(1)
{
head = new Node(MIN, 0, 1);
tail = new Node(MAX, 0, 1);
//初始化头和尾，头的权值为负无穷，
//尾的权值为正无穷，高度都为1。
head -> next[0] = tail; //最底层的初始化。
} //构造一个空的跳跃表。
};
SkipList skip;
Node *update[maxL];
//记忆化查找标记：update[i]为上一次查找到第i层的点。
int totnum[maxL], delta, tot, Lim;
//记忆化查找标记：totnum[i]为上一次查找到第i层与其
//右边相邻的点之间的节点个数（区间为左开右闭）。
inline int getint()
{
int res = 0; char tmp;
while (!isdigit(tmp = getchar()));
do res = (res << 3) + (res << 1) + tmp - '0';
while (isdigit(tmp = getchar()));
return res;
}
inline int Rand()
{
int tmp = 1;
while (rand() & 1)
{
++tmp;
if (tmp > skip.lev || tmp == maxL - 1)
break;
}
return tmp;
} //随机化算法，使加入高度为lev的概率为2^(-lev)。
inline Node *Find(int x)
{
Node *p = skip.head;
for (int i = skip.lev - 1; i > -1; --i)
{
for (totnum[i] = 0; p -> next[i] ->
key < x; p = p -> next[i])
totnum[i] += p -> sum[i];
update[i] = p;
}
return p;
} //在跳跃表中找到小于x的最大元素。
inline int Del()
{
Find(Lim - delta);
int cnt = 0;
for (int i = 0; i < skip.lev; ++i)
{
skip.head -> next[i] = update[i] -> next[i];
skip.head -> sum[i] = update[i] -> sum[i] - cnt;
cnt += totnum[i];
while (skip.lev > 1 && skip.head ->
next[skip.head -> lev - 2] == skip.tail)
{
skip.head -> sum[--skip.lev] = 0;
--(skip.head -> lev);
--(skip.tail -> lev);
} //删除多余的空链（注意必须保留一层空链在最高层）。
}
tot -= cnt;
return cnt;
} //在跳跃表中删除所有工资低于最低限度的点。
inline int Select(int k)
{
Node *p = skip.head;
for (int i = skip.lev - 1; i > -1; --i)
for (; p != skip.tail && k > 0 &&
p -> sum[i] < k; p = p -> next[i])
k -= p -> sum[i];
return p -> next[0] -> key;
} //在跳跃表中找出第k小的点。
inline void Ins(int x)
{
Node *p = Find(x);
if (p -> next[0] -> key == x)
{
p = p -> next[0]; ++(p -> cnt);
for (int i = 0; i < skip.lev; ++i)
++(update[i] -> sum[i]);
return;
}
//若x在跳跃表中已经存在，则直接将
//该竖列的元素数目加一，否则插入新链。
Node *t = new Node(x, 1, Rand());
for (int i = skip.lev; i < t -> lev + 1; ++i)
{
update[i] = skip.head;
update[i] -> sum[i] = tot;
update[i] -> next[i] = skip.tail;
totnum[i] = 0;
}
//若被插入的高度大于当前跳跃表
//的高度，则在上方插入新链。
if (t -> lev >= skip.lev)
skip.head -> lev = skip.tail -> lev
= skip.lev = t -> lev + 1;
int cnt = 0;
for (int i = 0; i < t -> lev; ++i)
{
t -> sum[i] = update[i] -> sum[i] - cnt;
t -> next[i] = update[i] -> next[i];
update[i] -> next[i] = t;
update[i] -> sum[i] = cnt + t -> cnt;
cnt += totnum[i];
} //依次插入新链。
for (int i = t -> lev; i < skip.lev; ++i)
update[i] -> sum[i] += t -> cnt;
//超过被插入的高度则直接加上该点权值即可。
return;
}
int main()
{
freopen("cashier.in", "r", stdin);
freopen("cashier.out", "w", stdout);
srand(time(NULL));
int t = getint(), ans = 0, x; Lim = getint();
for (; t; --t)
switch (scanf("\n"), getchar())
{
case 'I':
if ((x = getint()) >= Lim)
{Ins(x - delta); ++tot;}
break;
case 'A': delta += getint(); break;
case 'S':
delta -= getint();
ans += Del();
break;
case 'F':
printf("%d\n", (x = tot - getint() + 1)
> 0 ? (Select(x) + delta) : -1);
break;
}
printf("%d\n", ans);
return 0;
}
Splay版本：
/******************************\
* @prob: NOI2004 cashier *
* @auth: Wang Junji *
* @stat: Accepted. *
* @date: June. 9th, 2012 *
* @memo: 伸展树 *
\******************************/
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>
const int maxN = 100010;
class SplayTree
{
private:
struct Node
{
int key, sz, cnt; Node *lc, *rc, *F; Node() {}
Node(int key): key(key), sz(1), cnt(1) {}
} NIL[maxN], *tot, *T; int delta, Lim;
Node *NewNode(int key)
{
Node *T = new (++tot) Node(key);
T -> lc = T -> rc = T -> F = NIL;
return T;
}
void update(Node *T) {T -> sz = T -> lc -> sz + T -> rc -> sz + T -> cnt; return;}
void Zig(Node *T)
{
Node *P = T -> F, *tmp = T -> rc;
if (P == this -> T) this -> T = T;
else (P -> F -> lc == P) ? (P -> F -> lc = T) : (P -> F -> rc = T);
T -> F = P -> F; P -> F = T; P -> lc = tmp;
tmp -> F = T -> rc = P; update(P); return;
}
void Zag(Node *T)
{
Node *P = T -> F, *tmp = T -> lc;
if (P == this -> T) this -> T = T;
else (P -> F -> lc == P) ? (P -> F -> lc = T) : (P -> F -> rc = T);
T -> F = P -> F; P -> F = T; P -> rc = tmp;
tmp -> F = T -> lc = P; update(P); return;
}
void Splay(Node *&T, Node *t)
{
while (t != T)
{
Node *&P = t -> F;
if (P == T) (P -> lc == t) ? Zig(t) : Zag(t);
else
{
if (P -> F -> lc == P) (P -> lc == t) ? Zig(P) : Zag(t), Zig(t);
else (P -> lc == t) ? Zig(t) : Zag(P), Zag(t);
}
}
update(t); return;
}
Node *Ins(Node *&T, int v)
{
if (T == NIL) return T = NewNode(v); Node *tmp; ++T -> sz;
if (v == T -> key) {++T -> cnt; return T;}
if (v < T -> key) tmp = Ins(T -> lc, v), T -> lc -> F = T;
else tmp = Ins(T -> rc, v), T -> rc -> F = T;
return tmp;
}
void K_th(Node *&T, int k)
{
for (Node *t = T; t != NIL;)
{
if (k <= t -> lc -> sz + t -> cnt && k > t -> lc -> sz) {Splay(T, t); return;}
if (k <= t -> lc -> sz) t = t -> lc;
else k -= t -> lc -> sz + t -> cnt, t = t -> rc;
}
return;
}
void Find(Node *&T, int v)
{
for (Node *t = T; t != NIL;)
{
if (v == t -> key ||
(v < t -> key && t -> lc == NIL) ||
(v > t -> key && t -> rc == NIL))
{Splay(T, t); return;}
t = (v < t -> key) ? t -> lc : t -> rc;
}
return;
}
int Del()
{
int res = 0; if (T == NIL) return res; Find(T, Lim - delta);
if (T -> key < Lim - delta)
res = T -> lc -> sz + T -> cnt, T = T -> rc, T -> F = NIL;
else T -> sz -= res = T -> lc -> sz, T -> lc = NIL;
K_th(T, (T -> sz) >> 1); return res;
}
public:
SplayTree(): delta(0)
{NIL[0].sz = 0; T = tot = NIL[0].lc = NIL[0].rc = NIL[0].F = NIL;}
void set(int Lim) {this -> Lim = Lim; return;}
int Add(int val) {delta += val; return (val < 0) ? Del() : 0;}
void Ins(int v) {if (v >= Lim) Splay(T, Ins(T, v - delta)); return;}
int K_th(int k)
{
if (k > T -> sz) return -1;
K_th(T, T -> sz - k + 1);
return T -> key + delta;
}
} Tr; char ch; int T, Lim, ans, k;
int main()
{
freopen("cashier.in", "r", stdin);
freopen("cashier.out", "w", stdout);
scanf("%d%d", &T, &Lim); Tr.set(Lim);
while (T--) switch (scanf("\n%c%d", &ch, &k), ch)
{
case 'I': Tr.Ins(k); break;
case 'A': Tr.Add(k); break;
case 'S': ans += Tr.Add(-k); break;
case 'F': printf("%d\n", Tr.K_th(k)); break;
}
printf("%d\n", ans); return 0;
}
/*
注意每个结点都维护一个cnt，即相同的数的个数，否则删除的时候会出问题。
*/