【1172. 餐盘栈】

最新推荐文章于 2024-08-29 16:57:08 发布

千北@

最新推荐文章于 2024-08-29 16:57:08 发布

阅读量464

点赞数

分类专栏： LeetCode 文章标签：算法数据结构 leetcode c++

本文链接：https://blog.csdn.net/Sugar_wolf/article/details/130421687

版权

LeetCode 专栏收录该内容

397 篇文章 2 订阅

订阅专栏

来源：力扣（LeetCode）

描述：

我们把无限数量 ∞ 的栈排成一行，按从左到右的次序从 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;
};

执行用时：360 ms, 在所有 C++ 提交中击败了100.00%的用户
内存消耗：184.5 MB, 在所有 C++ 提交中击败了97.37%的用户
复杂度分析
时间复杂度：记 n 为 push 的调用次数。单次 push 的时间复杂度为 O(logn)，单次 popAtStack 的时间复杂度为 O(logn)，pop 单次均摊的时间复杂度为 O(logn)。
空间复杂度：使用到的数组和有序集合空间复杂度均为 O(n)。
author：LeetCode-Solution