【ACWing】950. 郁闷的出纳员

题目地址：

https://www.acwing.com/problem/content/952/

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$。输出文件的最后一行包含一个整数，为离开公司的员工的总数。注意，如果某个员工的初始工资低于最低工资标准，那么将不计入最后的答案内。

数据范围：
I命令的条数不超过$10^5$，
A命令和S命令的总条数不超过$100$，
F命令的条数不超过$10^5$，
每次工资调整的调整量不超过$1000$，
新员工的工资不超过$10^5$。

可以用Splay来做。Splay的基本知识可以参考https://blog.csdn.net/qq_46105170/article/details/121119399。由于本题里加薪和降薪是对所有员工而言的，所以可以开一个变量$d$存偏移量，这样每个员工的真实工资是其在Splay里的工资再加上$d$。接着开一个Splay作为BBST使用，这道题只需要执行下面的操作：
1、添加一个数。Splay可以直接做；
2、找第$k$个数。可以按照普通平衡树的方法做，每个节点存一个size；
3、找到所有小于某个数$x$的数，然后将这些数整个删除。可以先找到大于等于$x$的最小数$c$，然后将其splay到树根，然后将$-\infty$哨兵节点splay到树根下面，这样$-\infty$的右子树就是要删除的所有节点，一次性删除即可。当然也可以直接将$c$的左儿子置为哨兵，然后更新一下$c$和哨兵的父亲儿子关系，这样不需要splay两次。

代码如下：

#include <iostream>
using namespace std;

const int N = 1e5 + 10, INF = 1e9;
// delta是偏移量。每个人真正的工资是其在splay里的工资加上偏移量
int n, m, delta;
struct Node {
    
    
    int s[2], p, v;
    int size;
    void init(int _v, int _p) {
    
    
        v = _v;
        p = _p;
        size = 1;
    }
} tr[N];
int root, idx;

void pushup(int x) {
    
    
    tr[x].size = tr[tr[x].s[0]].size + tr[tr[x].s[1]].size + 1;
}

void rotate(int x) {
    
    
    int y = tr[x].p, z = tr[y].p;
    int k = tr[y].s[1] == x;
    tr[z].s[y == tr[z].s[1]] = x, tr[x].p = z;
    tr[y].s[k] = tr[x].s[k ^ 1], tr[tr[x].s[k ^ 1]].p = y;
    tr[x].s[k ^ 1] = y, tr[y].p = x;
    pushup(y), pushup(x);
}

void splay(int x, int g) {
    
    
    while (tr[x].p != g) {
    
    
        int y = tr[x].p, z = tr[y].p;
        if (z != g)
            if ((x == tr[y].s[1]) ^ (y == tr[z].s[1])) rotate(x);
            else rotate(y);
        rotate(x);
    }

    if (!g) root = x;
}

int insert(int v) {
    
    
    int u = root, p = 0;
    while (u) p = u, u = tr[u].s[v > tr[u].v];
    u = ++idx;
    if (p) tr[p].s[v > tr[p].v] = u;
    tr[u].init(v, p);
    splay(u, 0);
    return u;
}

// 找到大于等于v的最小值的那个节点
int get(int v) {
    
    
    int u = root, res;
    while (u) {
    
    
        if (tr[u].v >= v) res = u, u = tr[u].s[0];
        else u = tr[u].s[1];
    }

    return res;
}

// 找到第k小数
int get_k(int k) {
    
    
    int u = root;
    while (u) {
    
    
        if (tr[tr[u].s[0]].size >= k) u = tr[u].s[0];
        else if (tr[tr[u].s[0]].size + 1 < k){
    
    
            k -= tr[tr[u].s[0]].size + 1;
            u = tr[u].s[1];
        } else return tr[u].v;
    }

    return -1;
}

int main() {
    
    
    scanf("%d%d", &n, &m);
    // 先插入两个哨兵，即正负无穷
    int L = insert(-INF), R = insert(INF);
	
	// tot记录总共新加入了多少个员工
    int tot = 0;
    while (n--) {
    
    
        char op[2];
        int k;
        scanf("%s%d", op, &k);
        if (op[0] == 'I') {
    
    
        	// 只有工资大于等于工资下界他才会加入
            if (k >= m) {
    
    
            	// 将k减去偏移量存入splay中
                insert(k - delta);
                tot++;
            }
        } else if (op[0] == 'A') delta += k;
        else if (op[0] == 'S') {
    
    
            delta -= k;
            // 先找到大于等于m - delta的最小值的那个节点
            R = get(m - delta);
            // 将其splay到树根，将负无穷哨兵splay到树根下面
            splay(R, 0), splay(L, R);
            // 整体删除哨兵的右子树
            tr[L].s[1] = 0;
            // 删完了还需要pushup一下L和R节点
            pushup(L), pushup(R);
			
			// 也可以优化为下面几行，将R旋到树根，直接令其左儿子为L，
			// 更新L的父亲和右儿子，然后pushup两个节点
			// splay(R, 0);
            // tr[R].s[0] = L;
            // tr[L].p = R;
            // tr[L].s[1] = 0;
            // pushup(L), pushup(R);
        } else {
    
    
        	// 真正的员工个数是树的size减去两个哨兵
            if (tr[root].size - 2 < k) puts("-1");
            else printf("%d\n", get_k(tr[root].size - k) + delta);
        }
    }
    
    printf("%d\n", tot - (tr[root].size - 2));
    return 0; 
}

每次操作时间复杂度$O(\log n)$，空间$O(n)$。