1172. 餐盘栈

难度：困难

题目：

我们把无限数量 ∞ 的栈排成一行，按从左到右的次序从 0 开始编号。每个栈的的最大容量 capacity 都相同。

实现一个叫「餐盘」的类 DinnerPlates：

• DinnerPlates(int capacity) - 给出栈的最大容量 capacity。
• void push(int val) - 将给出的正整数 val 推入 从左往右第一个 没有满的栈。
• int pop() - 返回 从右往左第一个 非空栈顶部的值，并将其从栈中删除；如果所有的栈都是空的，请返回 -1。
• int popAtStack(int index) - 返回编号 index 的栈顶部的值，并将其从栈中删除；如果编号 index 的栈是空的，请返回 -1。

 

示例：

输入：
["DinnerPlates","push","push","push","push","push","popAtStack","push","push","popAtStack","popAtStack","pop","pop","pop","pop","pop"]
[[2],[1],[2],[3],[4],[5],[0],[20],[21],[0],[2],[],[],[],[],[]]
输出：
[null,null,null,null,null,null,2,null,null,20,21,5,4,3,1,-1]

解释：
DinnerPlates D = DinnerPlates(2);  // 初始化，栈最大容量 capacity = 2
D.push(1);
D.push(2);
D.push(3);
D.push(4);
D.push(5);         // 栈的现状为：    2  4
                                    1  3  5
                                    ﹈ ﹈ ﹈
D.popAtStack(0);   // 返回 2。栈的现状为：      4
                                          1  3  5
                                          ﹈ ﹈ ﹈
D.push(20);        // 栈的现状为：  20  4
                                   1  3  5
                                   ﹈ ﹈ ﹈
D.push(21);        // 栈的现状为：  20  4 21
                                   1  3  5
                                   ﹈ ﹈ ﹈
D.popAtStack(0);   // 返回 20。栈的现状为：       4 21
                                            1  3  5
                                            ﹈ ﹈ ﹈
D.popAtStack(2);   // 返回 21。栈的现状为：       4
                                            1  3  5
                                            ﹈ ﹈ ﹈ 
D.pop()            // 返回 5。栈的现状为：        4
                                            1  3 
                                            ﹈ ﹈  
D.pop()            // 返回 4。栈的现状为：    1  3 
                                           ﹈ ﹈   
D.pop()            // 返回 3。栈的现状为：    1 
                                           ﹈   
D.pop()            // 返回 1。现在没有栈。
D.pop()            // 返回 -1。仍然没有栈。

 

提示：

• 1 <= capacity <= 20000
• 1 <= val <= 20000
• 0 <= index <= 100000
• 最多会对 push，pop，和 popAtStack 进行 200000 次调用。

---

个人思路

解法一 数组+ 有序集合模拟

思路与算法

用一个数组 $stack$ 来模拟栈，编号为 $index$ 的栈的顶部 $stackTop$ 在数组中的下标 $pos$ 可以通过公式来表示：$pos=index×capacity+stackTop$。用一个有序集合 $poppedPos$ 来保存被方法 $popAtStack$ 删除的位置。用数组 $top$ 记录每个栈的栈顶元素在栈中的位置，比如 $top[1]=2$ 就表示，编号为 $1$ 的栈，栈顶元素在栈中的下标为 $2$（从 $0$ 开始计数，$capacity>2$），即在这个栈中，它上面没有元素，它下面还有两个元素。

执行 $push$ 时，先考虑 $poppedPos$ 中的位置，如果非空，则找出最小的位置，把元素 $push$ 到这个位置。如果为空，则往 $stack$ 后追加，然后更新 $top$。

执行 $popAtStack$ 时，先找出这个栈现在的栈顶位置，然后把这个位置的元素的下标计算出来并更新栈顶位置，把下标放入 $poppedPos$，返回元素的值。当然有可能这个栈是空的，此时要返回 $−1$。

执行 $pop$ 时，情况比较复杂。直观的想法是，返回 $stack$ 元素即可。但 $stack$ 末尾元素可能早已被 $popAtStack$ 删除，因此，应该返回处于 $stack$ 末尾且不位于 $popAtStack$ 中的位置，如果 $stack$ 末尾位置出现在 $popAtStack$ 中，直接把 $stack$ 末尾元素删除，再进行重复判断，直到满足上述条件或者 $stack$ 为空。找到符合条件的位置后，需要更新 $top$，然后返回元素的值。在执行 $pop$ 时，上述判断可能会执行多次，但是一次 $popAtStack$最多带来一次判断，因此不会带来时间复杂度的变大。

代码

class DinnerPlates {
public:
    DinnerPlates(int capacity) {
        this->capacity = capacity;
    }

    void push(int val) {
        if (poppedPos.empty()) {
            int pos = stk.size();
            stk.emplace_back(val);
            if (pos % capacity == 0) {
                top.emplace_back(0);
            } else {
                top.back()++;
            }
        } else {
            int pos = *poppedPos.begin();
            poppedPos.erase(pos);
            stk[pos] = val;
            int index = pos / capacity;
            top[index]++;
        }
    }
    
    int pop() {
        while (!stk.empty() && poppedPos.count(stk.size() - 1)) {
            stk.pop_back();
            int pos = *poppedPos.rbegin();
            poppedPos.erase(pos);
            if (pos % capacity == 0) {
                top.pop_back();
            }
        }
        if (stk.empty()) {
            return -1;
        } else {
            int pos = stk.size() - 1;
            int val = stk.back();
            stk.pop_back();
            if (pos % capacity == 0) {
                top.pop_back();
            } else {
                top.back() = top.size() - 2;
            }
            return val;
        }
    }
    
    int popAtStack(int index) {
        if (index >= top.size()) {
            return -1;
        }
        int stackTop = top[index];
        if (stackTop < 0) {
            return -1;
        }
        top[index]--;
        int pos = index * capacity + stackTop;
        poppedPos.emplace(pos);
        return stk[pos];
    }
private:
    int capacity;
    vector<int> stk;
    vector<int> top;
    set<int> poppedPos;
};

每天记录一下做题思路。