LeetCode-Python-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 次调用。

思路：

学习自大神的代码。

这题难点就是，

1. 怎么能快速找到从左到右第一个有空位栈的下标

2. 怎么能快速找到从右到左第一个非空栈的下标

对于问题1， 大神的解决办法是维护一个最小堆self.idx ，用来记录任意时刻，所有有空位栈的下标。

对于问题2， 大神的解决办法是从后往前直接找……PS 这里我觉得可以同理用一个最大堆来维护所有非空栈的下标。

from heapq import *
class DinnerPlates(object):
    def __init__(self, capacity):
        """
        :type capacity: int
        """
        self.stack = []
        self.c = capacity
        self.idx = [] #用于存放有空位的栈的下标

    def push(self, val):
        """
        :type val: int
        :rtype: None
        """
        if self.idx:
            index = heappop(self.idx) #找最小的空的栈的下标
            self.stack[index].append(val) #插入val
            if len(self.stack[index]) < self.c: #如果插了之后还没满，就把这个空的栈的下标放进self.idx
                heappush(self.idx, index)
        else: #现在所有栈都满了，只能新增一个栈在末尾
            self.stack.append([val])
            if self.c > 1:
                self.idx.append(len(self.stack) - 1)
            

    def pop(self):
        """
        :rtype: int
        """
        while self.stack and not self.stack[-1]:
            self.stack.pop()
        if not self.stack: #所有的栈都是空的
            return -1
        else:
            if len(self.stack[-1]) == self.c: #如果本来是满的栈
                heappush(self.idx, len(self.stack) - 1) #现在要变成有空位的栈了
            return self.stack[-1].pop()
            
    def popAtStack(self, index):
        """
        :type index: int
        :rtype: int
        """
        if index >= len(self.stack): #下标越界
            return -1
        else:
            s = self.stack[index] # 把下标为index的栈取出来
            if len(s) == self.c: #如果这个栈本来是满的
                heappush(self.idx, index) #马上要变空了
            return s.pop() if s else -1 #如果这个栈是空的，返回-1， 否则返回pop


# Your DinnerPlates object will be instantiated and called as such:
# obj = DinnerPlates(capacity)
# obj.push(val)
# param_2 = obj.pop()
# param_3 = obj.popAtStack(index)