LeetCode 1381题解析：支持增量操作的栈设计与优化

王饮刀

1. 问题分析与需求拆解

今天我们来深入探讨LeetCode第1381题——设计一个支持增量操作的栈。这道题看似简单，但其中蕴含着对栈这种基础数据结构的深刻理解和灵活运用。

首先明确题目要求：我们需要实现一个自定义栈结构，除了常规的push和pop操作外，还需要支持一个特殊操作——increment(k, val)，该操作能够将栈底的前k个元素都增加val值。如果栈中元素不足k个，则对所有元素进行增量操作。

这个问题的核心挑战在于：

如何在保证常规栈操作O(1)时间复杂度的情况下
高效实现increment操作
处理各种边界条件（空栈、k值过大等）

2. 基础实现方案解析

2.1 直接遍历法

最直观的解决方案就是题目中给出的基于vector的实现：

cpp复制class CustomStack {
public:
    vector<int> tr;
    int ms;
    CustomStack(int maxSize) {
        ms = maxSize;
    }
    
    void push(int x) {
        if(tr.size() < ms) tr.push_back(x);
    }
    
    int pop() {
        if(tr.size() == 0) return -1;
        int a = tr.back();
        tr.pop_back();
        return a;
    }
    
    void increment(int k, int val) {
        int r = min(k, (int)tr.size());
        for(int i = 0; i < r; i++) tr[i] += val;
    }
};

这个实现的特点：

使用vector作为底层存储
push和pop操作都是O(1)时间复杂度
increment操作在最坏情况下是O(n)时间复杂度

注意：这里pop操作在栈为空时返回-1，这是一个常见的错误处理方式，但实际工程中可能需要更明确的错误处理机制。

2.2 复杂度分析

让我们分析一下这个实现的时间复杂度：

构造函数：O(1)
push：O(1)（不考虑vector扩容的情况）
pop：O(1)
increment：O(k)

对于频繁调用increment操作的场景，这种实现效率可能不够理想。我们需要思考是否有优化空间。

3. 优化方案设计与实现

3.1 延迟增量法

我们可以采用"延迟增量"的策略来优化increment操作。基本思路是：

维护一个增量数组inc，记录各位置的待增量
当pop时，将当前位置的增量应用到元素上，并将部分增量"传递"给前一个元素
increment操作只需要在inc数组上做标记

实现代码如下：

cpp复制class CustomStack {
public:
    vector<int> stack;
    vector<int> inc;
    int maxSize;
    
    CustomStack(int maxSize) {
        this->maxSize = maxSize;
        inc.resize(maxSize);
    }
    
    void push(int x) {
        if (stack.size() < maxSize) {
            stack.push_back(x);
            inc[stack.size()-1] = 0;
        }
    }
    
    int pop() {
        if (stack.empty()) return -1;
        
        int index = stack.size() - 1;
        int res = stack.back() + inc[index];
        stack.pop_back();
        
        if (index > 0) {
            inc[index-1] += inc[index];
        }
        inc[index] = 0;
        
        return res;
    }
    
    void increment(int k, int val) {
        int i = min(k, (int)stack.size()) - 1;
        if (i >= 0) {
            inc[i] += val;
        }
    }
};

3.2 优化方案分析

这种实现的特点是：

push操作：O(1)
pop操作：O(1)（虽然看起来有多个操作，但都是常数时间）
increment操作：O(1)

空间复杂度：O(n)，因为需要额外的inc数组

这种方案特别适合increment操作频繁而pop操作相对较少的场景。它通过空间换时间，将increment操作的时间复杂度从O(k)降到了O(1)。

4. 边界条件与异常处理

在实际实现中，我们需要特别注意以下边界条件：

栈满时的push操作：
- 题目要求当栈达到maxSize时，push操作应该被忽略
- 实现时要先检查当前size
空栈时的pop操作：
- 题目要求返回-1
- 实际工程中可能需要抛出异常或返回错误码
increment操作的k值处理：
- 当k大于当前栈大小时，应该对所有元素进行增量
- 使用min(k, stack.size())确保安全
maxSize为0或负数的情况：
- 虽然题目测试用例可能不包含这种情况
- 但健壮的实现应该处理这些异常输入

5. 测试用例设计

为了验证我们的实现是否正确，应该设计全面的测试用例：

cpp复制void testCustomStack() {
    // 基础功能测试
    CustomStack s(3);
    s.push(1); s.push(2); s.push(3);
    assert(s.pop() == 3);
    s.push(4);
    s.increment(2, 100);
    assert(s.pop() == 104);
    assert(s.pop() == 102);
    assert(s.pop() == 1);
    
    // 边界测试
    CustomStack s2(1);
    assert(s2.pop() == -1);  // 空栈pop
    s2.push(1);
    s2.push(2);  // 应该被忽略
    assert(s2.pop() == 1);
    
    // increment特殊情况
    CustomStack s3(5);
    s3.push(1); s3.push(2); s3.push(3);
    s3.increment(5, 10);  // k大于栈大小
    assert(s3.pop() == 3);
    assert(s3.pop() == 12);
    assert(s3.pop() == 11);
}