LeetCode 1381. 设计一个支持增量操作的栈

1381. 设计一个支持增量操作的栈

请你设计一个支持对其元素进行增量操作的栈。

实现自定义栈类 CustomStack ：

• CustomStack(int maxSize)：用 maxSize 初始化对象，maxSize 是栈中最多能容纳的元素数量。
• void push(int x)：如果栈还未增长到 maxSize ，就将 x 添加到栈顶。
• int pop()：弹出栈顶元素，并返回栈顶的值，或栈为空时返回 -1 。
• void inc(int k, int val)：栈底的 k 个元素的值都增加 val 。如果栈中元素总数小于 k ，则栈中的所有元素都增加 val 。

示例：

输入：
["CustomStack","push","push","pop","push","push","push","increment","increment","pop","pop","pop","pop"]
[[3],[1],[2],[],[2],[3],[4],[5,100],[2,100],[],[],[],[]]
输出：
[null,null,null,2,null,null,null,null,null,103,202,201,-1]
解释：
CustomStack stk = new CustomStack(3); // 栈是空的 []
stk.push(1);                          // 栈变为 [1]
stk.push(2);                          // 栈变为 [1, 2]
stk.pop();                            // 返回 2 --> 返回栈顶值 2，栈变为 [1]
stk.push(2);                          // 栈变为 [1, 2]
stk.push(3);                          // 栈变为 [1, 2, 3]
stk.push(4);                          // 栈仍然是 [1, 2, 3]，不能添加其他元素使栈大小变为 4
stk.increment(5, 100);                // 栈变为 [101, 102, 103]
stk.increment(2, 100);                // 栈变为 [201, 202, 103]
stk.pop();                            // 返回 103 --> 返回栈顶值 103，栈变为 [201, 202]
stk.pop();                            // 返回 202 --> 返回栈顶值 202，栈变为 [201]
stk.pop();                            // 返回 201 --> 返回栈顶值 201，栈变为 []
stk.pop();                            // 返回 -1 --> 栈为空，返回 -1

提示：

• 1 <= maxSize, x, k <= 1000
• 0 <= val <= 100
• 每种方法 increment，push 以及 pop 分别最多调用 1000 次

---

提示 1

Use an array to represent the stack. Push will add new integer to the array. Pop removes the last element in the array and increment will add val to the first k elements of the array.

---

提示 2

This solution run in O(1) per push and pop and O(k) per increment.

解法1: 模拟

我们使用数组模拟栈，用一个变量 i 来记录当前栈顶的位置。

对于 push 操作，首先判断当前元素的个数是否达到上限，如果没有达到，就把 i 后移一个位置并添加一个元素。

对于 pop 操作，首先判断当前栈是否为空，非空返回栈顶元素并将 i 前移一位，否则返回 −1。

对于 inc 操作，直接对栈底的最多 k 个元素加上 val。

Java版：

class CustomStack {
    int[] stack;
    int m;
    int i;

    public CustomStack(int maxSize) {
        stack = new int[maxSize];
        m = maxSize;
        i = -1;
    }
    
    public void push(int x) {
        if (i < m - 1) {
            stack[i + 1] = x;
            i++;
        }
    }
    
    public int pop() {
        return i == -1 ? -1 : stack[i--];
    }
    
    public void increment(int k, int val) {
        for (int j = 0; j < k && j <= i; j++) {
            stack[j] += val;
        }
    }
}

/**
 * Your CustomStack object will be instantiated and called as such:
 * CustomStack obj = new CustomStack(maxSize);
 * obj.push(x);
 * int param_2 = obj.pop();
 * obj.increment(k,val);
 */

Python3版：

class CustomStack:

    def __init__(self, maxSize: int):
        self.m = maxSize
        self.stack = [0] * maxSize
        self.i = -1

    def push(self, x: int) -> None:
        if self.i < self.m - 1:
            self.i += 1
            self.stack[self.i] = x

    def pop(self) -> int:
        if self.i == -1:
            return -1
        v = self.stack[self.i]
        self.i -= 1
        return v

    def increment(self, k: int, val: int) -> None:
        for j in range(min(k, self.i + 1)):
            self.stack[j] += val


# Your CustomStack object will be instantiated and called as such:
# obj = CustomStack(maxSize)
# obj.push(x)
# param_2 = obj.pop()
# obj.increment(k,val)

复杂度分析

• 时间复杂度：初始化（构造函数）、push 操作和 pop 操作的渐进时间复杂度为 O(1)，inc 操作的渐进时间复杂度为 O(k)。
• 空间复杂度：这里用到了一个长度为 maxSize 的数组作为辅助空间，渐进空间复杂度为 O(maxSize)。