LeetCode LCR 184. 设计自助结算系统

LCR 184. 设计自助结算系统

请设计一个自助结账系统，该系统需要通过一个队列来模拟顾客通过购物车的结算过程，需要实现的功能有：

• get_max()：获取结算商品中的最高价格，如果队列为空，则返回 -1
• add(value)：将价格为 value 的商品加入待结算商品队列的尾部
• remove()：移除第一个待结算的商品价格，如果队列为空，则返回 -1

注意，为保证该系统运转高效性，以上函数的均摊时间复杂度均为 O(1)

示例 1：

输入: 
["Checkout","add","add","get_max","remove","get_max"]
[[],[4],[7],[],[],[]]

输出: [null,null,null,7,4,7]

示例 2：

输入: 
["Checkout","remove","get_max"]
[[],[],[]]

输出: [null,-1,-1]

提示：

• 1 <= get_max, add, remove 的总操作数 <= 10000
• 1 <= value <= 10^5

解法1：单调队列

单调队列同类题型详解：LeetCode 239. 滑动窗口最大值-CSDN博客

本算法基于问题的一个重要性质：当一个元素进入队列的时候，它前面所有比它小的元素就不会再对答案产生影响。

举个例子，如果我们向队列中插入数字序列 1 1 1 1 2，那么在第一个数字 2 被插入后，数字 2 前面的所有数字 1 将不会对结果产生影响。因为按照队列的取出顺序，数字 2 只能在所有的数字 1 被取出之后才能被取出，因此如果数字 1 如果在队列中，那么数字 2 必然也在队列中，使得数字 1 对结果没有影响。

按照上面的思路，我们可以设计这样的方法：从队列尾部插入元素时，我们可以提前取出队列中所有比这个元素小的元素，使得队列中只保留对结果有影响的数字。这样的方法等价于要求维持队列单调递减，即要保证每个元素的前面都没有比它小的元素。

那么如何高效实现一个始终递减的队列呢？我们只需要在插入每一个元素 value 时，从队列尾部依次取出比当前元素 value 小的元素，直到遇到一个比当前元素大的元素 value' 即可。

上面的过程保证了只要在元素 value 被插入之前队列递减，那么在 value 被插入之后队列依然递减。
而队列的初始状态（空队列）符合单调递减的定义。
由数学归纳法可知队列将会始终保持单调递减。
上面的过程需要从队列尾部取出元素，因此需要使用双端队列来实现。另外我们也需要一个辅助队列来记录所有被插入的值，以确定 remove 函数的返回值。

保证了队列单调递减后，求最大值时只需要直接取双端队列中的第一项即可。

Java版：

class Checkout {
    Deque<Integer> queue;
    Deque<Integer> mqueue;

    public Checkout() {
        queue = new ArrayDeque<>();
        mqueue = new ArrayDeque<>();
    }
    
    public int get_max() {
        if (mqueue.isEmpty()) {
            return -1;
        }
        return mqueue.peek();
    }
    
    public void add(int value) {
        queue.offer(value);
        while (!mqueue.isEmpty() && value >= mqueue.peekLast()) {
            mqueue.pollLast();
        }
        mqueue.offer(value);
    }
    
    public int remove() {
        if (queue.isEmpty()) {
            return -1;
        }
        int v = queue.poll();
        if (v == mqueue.peek()) {
            mqueue.poll();
        }
        return v;
    }
}

/**
 * Your Checkout object will be instantiated and called as such:
 * Checkout obj = new Checkout();
 * int param_1 = obj.get_max();
 * obj.add(value);
 * int param_3 = obj.remove();
 */

Python3版：

class Checkout:

    def __init__(self):
        self.queue = deque()
        self.mqueue = deque()

    def get_max(self) -> int:
        if not self.mqueue:
            return -1
        return self.mqueue[0]

    def add(self, value: int) -> None:
        self.queue.append(value)
        while self.mqueue and value >= self.mqueue[-1]:
            self.mqueue.pop()
        self.mqueue.append(value)

    def remove(self) -> int:
        if not self.queue:
            return -1
        v = self.queue.popleft()
        if v == self.mqueue[0]:
            self.mqueue.popleft()
        return v

# Your Checkout object will be instantiated and called as such:
# obj = Checkout()
# param_1 = obj.get_max()
# obj.add(value)
# param_3 = obj.remove()

复杂度分析

• 时间复杂度：O(1)（插入，删除，求最大值）
• 删除操作于求最大值操作显然只需要 O(1) 的时间。
• 而插入操作虽然看起来有循环，做一个插入操作时最多可能会有 n 次出队操作。但要注意，由于每个数字只会出队一次，因此对于所有的 n 个数字的插入过程，对应的所有出队操作也不会大于 n 次。因此将出队的时间均摊到每个插入操作上，时间复杂度为 O(1)。
• 空间复杂度：O(n)，需要用队列存储所有插入的元素。