滑动窗口与单调队列算法实战精讲

1. 算法实战：滑动窗口与单调队列精讲

作为一名在算法竞赛和面试辅导领域深耕多年的从业者，我经常遇到学员对滑动窗口和单调队列这两个高频考点感到困惑。今天我将通过LeetCode三道经典题目（560. 和为K的子数组、239. 滑动窗口最大值、76. 最小覆盖子串），带大家彻底掌握这些核心算法的底层原理和实战技巧。

2. 前缀和破解子数组求和问题

2.1 问题本质与暴力解法

560题要求统计数组中所有和为K的连续子数组数量。最直观的暴力解法是双重循环枚举所有子数组，时间复杂度O(n²)。但当数组长度达到2×10⁴时，这种解法必然超时。

关键观察：子数组的和可以转化为前缀和的差值。设前缀和数组s，则s[j]-s[i]正好表示子数组nums[i+1...j]的和。这个转化将问题从"子数组和"转换为"前缀和差值"。

2.2 优化后的前缀和解法

cpp复制class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        unordered_map<int, int> prefixSumCount;
        prefixSumCount[0] = 1; // 处理从0开始的子数组
        int sum = 0, count = 0;
        
        for (int num : nums) {
            sum += num;
            if (prefixSumCount.find(sum - k) != prefixSumCount.end()) {
                count += prefixSumCount[sum - k];
            }
            prefixSumCount[sum]++;
        }
        return count;
    }
};

核心要点解析：

1. 哈希表优化：使用哈希表记录前缀和出现次数，将时间复杂度降至O(n)
2. 初始化技巧：prefixSumCount[0]=1处理sum直接等于k的情况
3. 负数处理：由于存在负数，相同前缀和可能多次出现

2.3 实战中的常见错误

1. 忘记初始化prefixSumCount[0]导致漏解
2. 先更新count还是先更新哈希表的顺序错误
3. 使用数组而非哈希表导致空间浪费

3. 单调队列的魔法：滑动窗口最大值

3.1 单调队列设计原理

239题需要在O(n)时间内解决滑动窗口最大值问题。单调队列通过维护一个递减队列，保证队首始终是当前窗口最大值。

cpp复制class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        deque<int> dq;
        vector<int> res;
        
        for (int i = 0; i < nums.size(); ++i) {
            // 移除超出窗口范围的元素
            if (!dq.empty() && dq.front() == i - k) {
                dq.pop_front();
            }
            
            // 维护单调递减性
            while (!dq.empty() && nums[dq.back()] < nums[i]) {
                dq.pop_back();
            }
            
            dq.push_back(i);
            
            // 记录结果
            if (i >= k - 1) {
                res.push_back(nums[dq.front()]);
            }
        }
        return res;
    }
};

3.2 关键操作解析

1. 过期元素处理：检查队首索引是否已超出当前窗口范围
2. 单调性维护：从队尾移除所有小于当前元素的索引
3. 结果记录时机：当窗口形成后（i >= k-1）才开始记录

3.3 性能对比

4. 滑动窗口的进阶应用：最小覆盖子串

4.1 问题转化与解法框架

76题要求在字符串s中找到包含t所有字符的最短子串。这类"满足条件的最小区间"问题通常采用滑动窗口模板：

cpp复制string minWindow(string s, string t) {
    unordered_map<char, int> need, window;
    for (char c : t) need[c]++;
    
    int left = 0, right = 0;
    int valid = 0;
    int start = 0, len = INT_MAX;
    
    while (right < s.size()) {
        // 右扩窗口
        char c = s[right++];
        if (need.count(c)) {
            window[c]++;
            if (window[c] == need[c]) valid++;
        }
        
        // 左缩窗口
        while (valid == need.size()) {
            if (right - left < len) {
                start = left;
                len = right - left;
            }
            char d = s[left++];
            if (need.count(d)) {
                if (window[d] == need[d]) valid--;
                window[d]--;
            }
        }
    }
    return len == INT_MAX ? "" : s.substr(start, len);
}

4.2 关键优化点

1. valid计数器：避免每次检查整个哈希表
2. 边界处理：注意right++的副作用和left++的时机
3. 字符频率匹配：只有当window[c]等于need[c]时才增加valid

4.3 同类问题扩展

1. 找到字符串中所有字母异位词（LeetCode 438）
2. 无重复字符的最长子串（LeetCode 3）
3. 最大连续1的个数III（LeetCode 1004）

5. 算法选择决策树

面对子数组/子字符串问题时，可参考以下决策流程：

code复制是否要求连续？ → 否 → 考虑回溯或DP
    ↓是
是否需要精确匹配？ → 是 → 滑动窗口（如最小覆盖子串）
    ↓否
是否涉及区间和？ → 是 → 前缀和+哈希（如和为K的子数组）
    ↓否
是否需要区间最值？ → 是 → 单调队列（如滑动窗口最大值）
    ↓否
考虑普通滑动窗口或双指针

6. 调试技巧与边界案例

6.1 通用调试方法

1. 小数据测试：先用手算验证简单案例
2. 打印中间状态：在关键步骤输出变量值
3. 边界检查：特别注意空输入、单元素、全相同元素等情况

6.2 典型边界案例

7. 工程实践中的优化技巧

1. 内存预分配：对于固定大小的滑动窗口，提前分配结果数组空间
2. 哈希表替代数组：当字符集很大时（如Unicode），使用unordered_map而非固定数组
3. 早期终止：在某些问题中，当找到可能的最优解时可提前退出

8. 复杂度分析进阶

8.1 均摊分析

单调队列的每个元素最多入队出队各一次，虽然单次操作可能是O(n)，但总体是O(n)

8.2 空间复杂度优化

对于固定字符集的问题（如仅字母），可用大小为128的数组替代哈希表

9. 面试应答策略

1. 先阐明暴力解法：展示问题理解能力
2. 逐步优化：解释每个优化步骤的思考过程
3. 讨论trade-off：时空复杂度的权衡选择
4. 准备测试案例：主动提出边界案例展示严谨性

10. 扩展学习建议

1. 单调栈：解决类似"下一个更大元素"问题
2. 双指针技巧：处理排序数组的子集问题
3. 线段树/RMQ：解决更一般的区间查询问题

在实际刷题过程中，我建议将这三道题作为滑动窗口和单调队列的基准测试题。每道题至少手写3遍，直到能无bug一次通过。对于工程面试，滑动窗口的应用频率尤其高，需要重点掌握其变种问题的解法。