滑动窗口算法详解与C++实现

什么是滑动窗口算法

滑动窗口算法（Sliding Window Algorithm）是一种用于处理数组或列表子区间问题的高效技巧。它通过维护一个大小可变或固定的"窗口"在数据结构上滑动，从而避免不必要的重复计算，将许多嵌套循环的问题转化为单循环问题，显著降低时间复杂度。

滑动窗口的适用场景

滑动窗口算法通常适用于解决以下类型的问题：

寻找满足某种条件的子数组/子字符串
计算子数组/子字符串的最值或平均值
涉及连续元素的问题
需要优化嵌套循环为单循环的问题

滑动窗口的基本思想

滑动窗口算法的核心思想是维护一个窗口，该窗口通常由两个指针（左指针和右指针）表示。通过调整这两个指针的位置来扩大或缩小窗口，同时根据问题需求更新计算结果。

滑动窗口的两种类型

1. 固定大小的滑动窗口

窗口大小在滑动过程中保持不变，通常用于计算固定长度子数组的相关问题。

2. 可变大小的滑动窗口

窗口大小会根据特定条件动态调整，通常用于寻找满足特定条件的最长子数组或最短子数组。

C++实现示例

示例1：固定大小滑动窗口 - 计算大小为k的子数组的最大和

cpp 复制代码

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int maxSumSubarray(const vector<int>& nums, int k) {
    if (nums.size() < k) return -1; // 处理异常情况
    
    int max_sum = 0;
    // 计算初始窗口的和
    for (int i = 0; i < k; ++i) {
        max_sum += nums[i];
    }
    
    int window_sum = max_sum;
    // 滑动窗口
    for (int i = k; i < nums.size(); ++i) {
        window_sum += nums[i] - nums[i - k]; // 加上新元素，减去旧元素
        max_sum = max(max_sum, window_sum);
    }
    
    return max_sum;
}

int main() {
    vector<int> nums = {1, 4, 2, 10, 2, 3, 1, 0, 20};
    int k = 4;
    cout << "Maximum sum of a subarray of size " << k 
         << " is " << maxSumSubarray(nums, k) << endl;
    return 0;
}

示例2：可变大小滑动窗口 - 无重复字符的最长子字符串

cpp 复制代码

#include <iostream>
#include <string>
#include <unordered_set>
#include <algorithm>

using namespace std;

int lengthOfLongestSubstring(const string& s) {
    unordered_set<char> char_set;
    int left = 0, max_len = 0;
    
    for (int right = 0; right < s.size(); ++right) {
        // 如果当前字符已经存在于集合中，移动左指针
        while (char_set.find(s[right]) != char_set.end()) {
            char_set.erase(s[left]);
            ++left;
        }
        // 插入当前字符
        char_set.insert(s[right]);
        // 更新最大长度
        max_len = max(max_len, right - left + 1);
    }
    
    return max_len;
}

int main() {
    string s = "abcabcbb";
    cout << "Length of the longest substring without repeating characters: "
         << lengthOfLongestSubstring(s) << endl;
    return 0;
}

示例3：可变大小滑动窗口 - 最小覆盖子串

cpp 复制代码

#include <iostream>
#include <string>
#include <unordered_map>
#include <climits>

using namespace std;

string minWindow(string s, string t) {
    unordered_map<char, int> target_counts;
    for (char c : t) {
        target_counts[c]++;
    }
    
    int required = target_counts.size();
    int formed = 0;
    int left = 0;
    int min_len = INT_MAX;
    int start_idx = 0;
    unordered_map<char, int> window_counts;
    
    for (int right = 0; right < s.size(); ++right) {
        char c = s[right];
        window_counts[c]++;
        
        if (target_counts.count(c) && window_counts[c] == target_counts[c]) {
            formed++;
        }
        
        while (formed == required && left <= right) {
            // 更新最小窗口
            if (right - left + 1 < min_len) {
                min_len = right - left + 1;
                start_idx = left;
            }
            
            // 尝试缩小窗口
            char left_char = s[left];
            window_counts[left_char]--;
            if (target_counts.count(left_char) && 
                window_counts[left_char] < target_counts[left_char]) {
                formed--;
            }
            left++;
        }
    }
    
    return min_len == INT_MAX ? "" : s.substr(start_idx, min_len);
}

int main() {
    string s = "ADOBECODEBANC";
    string t = "ABC";
    cout << "Minimum window substring: " << minWindow(s, t) << endl;
    return 0;
}

滑动窗口算法的时间复杂度

滑动窗口算法通常可以将O(n²)或O(n³)的暴力解法优化到O(n)的时间复杂度，因为每个元素最多被访问两次（一次由右指针，一次由左指针）。

滑动窗口算法的关键点

窗口表示：通常用两个指针（左指针和右指针）表示窗口的边界
窗口扩张：右指针移动，扩大窗口，寻找可行解
窗口收缩：左指针移动，缩小窗口，优化可行解
结果更新：在窗口滑动过程中不断更新最优解

常见问题及解决方案

如何确定窗口何时扩展或收缩？
- 通常当窗口不满足条件时扩展，满足条件时尝试收缩
如何处理重复元素？
- 可以使用哈希表或数组来记录窗口内元素的频率
如何初始化窗口？
- 根据问题需求，可以初始化为空窗口或包含前k个元素的窗口

练习题

找到字符串中所有字母异位词（LeetCode 438）
最大连续1的个数 III（LeetCode 1004）
替换后的最长重复字符（LeetCode 424）
水果成篮（LeetCode 904）
长度最小的子数组（LeetCode 209）

总结

滑动窗口算法是解决数组/字符串子区间问题的高效技巧，通过维护动态窗口避免了不必要的重复计算。掌握滑动窗口算法需要理解其核心思想，并通过大量练习熟悉各种变种问题。在实际应用中，需要根据具体问题灵活调整窗口的扩展和收缩条件。