郁闷的出纳员

一 问题描述

有个郁闷的出纳员，他负责统计员工的工资，但老板经常把每位员工的工资都加上或扣除一个相同的量。一旦某位员工发现工资低于工资下限，他就会立刻辞职。每位员工的工资下限都是统一规定的，每次有员工辞职，都要删去其工资档案；每次招聘一位新员工，都要为其新建一个工资档案。老板经常询问现在工

资第 k 多的员工拿多少工资。

二 输入和输出

1 输入

第 1 行包含两个非负整数 n 和 min，n 表示命令的数量，min 表示工资下限。接下来输入 n 行，每行都表示一条命令。其中：I k 命令表示新建一个工资档案，初始工资为 k 。若某员工的初始工资低于工资下限，则他将立刻辞职；A k 命令表示把每位员工的工资都加上 k ；S k 命令表示把每位员工的工资都扣除 k ；F k 命令表示查询第 k 多的工资。开始时公司里一个员工也没有。数据范围：I 命令的条数不超过10^5 ；A 和 S 命令的总条数不超过 100；F 命令的条数不超过10^5 ；工资的每次调整量都不超过10^3 ；新员工的工资不超过10^5 。

2 输出

输出文件的行数为 F 命令的条数加 1。对每条 F 命令都输出一行，仅包含一个整数，为当前工资第 k 多的员工所拿的工资，若 k 大于当前员工的数量，则输出 -1。最后一行输出一个整数，为辞职的员工的总数。

三 输入和输出样例

1 输入样例

9 10

I 60

I 70

S 50

F 2

I 30

S 15

A 5

F 1

F 2

2 输出样例

10

20

-1

2

四 分析和设计

1 分析

本问题求解第 k 大的数，转换为求第 size-k+1 小的数即可。在此采用 SBT 解决。

2 设计

（1）可以设置变量 add，记录增加的工资量。增加工资 k 时，直接 add+=k 即可。

（2）插入新的员工工资 k 时，若 k 大于或等于下限，则将 k-add 插入 SBT 中。

（3）扣除工资 k 时，add-=k 。然后进行判断：若 SBT 不为空，则读出 最小工资+add，若小于下限，则删除该节点，辞职的员工总数 ans++，直到所有员工的工资都不小于下限为止。

（4）查询第 k 大时，若 k 大于 SBT 的大小 size，则输出 -1，否则查询第 size-k +1 小的数，加上 add 后输出。

五 代码

package com.platform.modules.alg.alglib.p1486;

public class P1486 {
    public String output = "";
    private int maxn = 100010;
    int n, cnt; // 结点数，结点存储下标累计
    // 树根
    nodePtr root = new nodePtr();
    int Min, ans, add, k, j;//工作下限，离开公司员工数
    char ch;
    node tr[] = new node[maxn];

    public P1486() {
        for (int i = 0; i < tr.length; i++) {
            tr[i] = new node();
        }
    }

    public String cal(String input) {
        String[] line = input.split("\n");
        String[] num = line[0].split(" ");
        n = Integer.parseInt(num[0]);
        Min = Integer.parseInt(num[1]);
        ans = add = 0;
        for (int i = 0; i < n; i++) {
            String[] command = line[i + 1].split(" ");
            ch = command[0].charAt(0);
            k = Integer.parseInt(command[1]);

            if (ch == 'I' && k >= Min) insert(root, k - add);
            else if (ch == 'A') add += k;
            else if (ch == 'S') {
                add -= k;
                while (tr[root.ptr].size > 0 && (j = get_kth(root, 1)) + add < Min) {
                    remove(root, j);
                    ans++;
                }
            } else if (ch == 'F') {
                if (k > tr[root.ptr].size) {
                    output += "-1\n";
                } else {
                    output += get_kth(root, tr[root.ptr].size - k + 1) + add + "\n";
                }
            }
        }
        output += ans + "\n";
        return output;
    }

    void R_rotate(nodePtr x) {
        int y = tr[x.ptr].lc.ptr;
        tr[x.ptr].lc.ptr = tr[y].rc.ptr;
        tr[y].rc.ptr = x.ptr;
        tr[y].size = tr[x.ptr].size;
        tr[x.ptr].size = tr[tr[x.ptr].lc.ptr].size + tr[tr[x.ptr].rc.ptr].size + 1;
        x.ptr = y;
    }

    void L_rotate(nodePtr x) {
        int y = tr[x.ptr].rc.ptr;
        tr[x.ptr].rc.ptr = tr[y].lc.ptr;
        tr[y].lc.ptr = x.ptr;
        tr[y].size = tr[x.ptr].size;
        tr[x.ptr].size = tr[tr[x.ptr].lc.ptr].size + tr[tr[x.ptr].rc.ptr].size + 1;
        x.ptr = y;
    }

    void maintain(nodePtr p, boolean flag) {
        if (p.ptr == 0) return;
        if (!flag) {
            if (tr[tr[tr[p.ptr].lc.ptr].lc.ptr].size > tr[tr[p.ptr].rc.ptr].size) // LL
                R_rotate(p);
            else if (tr[tr[tr[p.ptr].lc.ptr].rc.ptr].size > tr[tr[p.ptr].rc.ptr].size) { // LR
                L_rotate(tr[p.ptr].lc);
                R_rotate(p);
            } else return;
        } else {
            if (tr[tr[tr[p.ptr].rc.ptr].rc.ptr].size > tr[tr[p.ptr].lc.ptr].size)//RR
                L_rotate(p);
            else if (tr[tr[tr[p.ptr].rc.ptr].lc.ptr].size > tr[tr[p.ptr].lc.ptr].size) {//RL
                R_rotate(tr[p.ptr].rc);
                L_rotate(p);
            } else return;
        }
        maintain(tr[p.ptr].lc, false);
        maintain(tr[p.ptr].rc, true);
        maintain(p, false);
        maintain(p, true);
    }

    void insert(nodePtr p, int val) {
        if (p.ptr == 0) {
            p.ptr = ++cnt;
            tr[p.ptr].lc.ptr = tr[p.ptr].rc.ptr = 0;
            tr[p.ptr].size = 1;
            tr[p.ptr].val = val;
        } else {
            tr[p.ptr].size++;
            if (val < tr[p.ptr].val) insert(tr[p.ptr].lc, val);
            else insert(tr[p.ptr].rc, val);
            maintain(p, val >= tr[p.ptr].val);
        }
    }

    int remove(nodePtr p, int val) {
        tr[p.ptr].size--;
        if ((tr[p.ptr].val == val) || (tr[p.ptr].val > val && 0 == tr[p.ptr].lc.ptr) || (tr[p.ptr].val < val && 0 == tr[p.ptr].rc.ptr)) {
            int tmp = tr[p.ptr].val;
            if (0 == tr[p.ptr].lc.ptr || 0 == tr[p.ptr].rc.ptr)//有一个儿子为空，直接用儿子代替
                p.ptr = tr[p.ptr].lc.ptr + tr[p.ptr].rc.ptr;
            else // 找前驱，左子树最右节点
                tr[p.ptr].val = remove(tr[p.ptr].lc, tr[p.ptr].val + 1);
            return tmp;
        } else if (val < tr[p.ptr].val) return remove(tr[p.ptr].lc, val);
        else return remove(tr[p.ptr].rc, val);
    }

    // 求第 k 小数
    int get_kth(nodePtr p, int k) { // 求第 k 小数
        int s = tr[tr[p.ptr].lc.ptr].size + 1;
        if (s == k) return tr[p.ptr].val;
        else if (s < k) return get_kth(tr[p.ptr].rc, k - s);
        else return get_kth(tr[p.ptr].lc, k);
    }
}

class node {
    nodePtr lc = new nodePtr(); // 左孩子
    nodePtr rc = new nodePtr(); // 右孩子
    int val; // 值
    int size; // 子树大小
}

class nodePtr {
    int ptr;
}

六 测试