滑动窗口模板

Tue, 04 Aug 2026 00:00:00 +0000

1 核心思想

维护一个窗口 [left, right]，right 不断向右扩展，满足条件时 left 向右收缩，窗口内的元素始终满足某个条件。

适用场景： 子数组 / 子串问题，求最长 / 最短 / 数量

2 一、模板框架

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


int slidingWindow(vector<int>& nums) {
    int left = 0, ans = 0;
    // 窗口状态变量（计数、求和等）

    for (int right = 0; right < nums.size(); right++) {
        // 1. 右端点进入窗口，更新窗口状态

        while (窗口不满足条件) {  // 或 if，看题目
            // 2. 左端点移出窗口，更新窗口状态
            left++;
        }

        // 3. 此时窗口是合法的，更新答案
        ans = max(ans, right - left + 1);
    }
    return ans;
}

3 二、经典题型

3.1 题型 1：最长无重复子串（LeetCode 3）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


int lengthOfLongestSubstring(string s) {
    unordered_map<char, int> window;
    int left = 0, ans = 0;

    for (int right = 0; right < s.size(); right++) {
        char c = s[right];
        window[c]++;

        while (window[c] > 1) {  // 出现重复，收缩
            char d = s[left];
            window[d]--;
            left++;
        }

        ans = max(ans, right - left + 1);
    }
    return ans;
}

3.2 题型 2：最小覆盖子串（LeetCode 76）

找 s 中包含 t 所有字符的最短子串。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


string minWindow(string s, string t) {
    unordered_map<char, int> need, window;
    for (char c : t) need[c]++;

    int left = 0, valid = 0;
    int start = 0, minLen = INT_MAX;

    for (int right = 0; right < s.size(); right++) {
        char c = s[right];
        if (need.count(c)) {
            window[c]++;
            if (window[c] == need[c]) valid++;
        }

        while (valid == need.size()) {  // 满足条件，收缩找最小
            if (right - left + 1 < minLen) {
                minLen = right - left + 1;
                start = left;
            }

            char d = s[left];
            if (need.count(d)) {
                if (window[d] == need[d]) valid--;
                window[d]--;
            }
            left++;
        }
    }
    return minLen == INT_MAX ? "" : s.substr(start, minLen);
}

3.3 题型 3：和为 K 的子数组个数（前缀和+哈希）

注意：有负数时不能用滑动窗口，因为窗口不单调，要用前缀和+哈希。

4 三、什么时候用滑动窗口？

4.1 能用滑动窗口的条件

数组元素都是正数（窗口扩展和增大，收缩和减小）
求子数组的最长 / 最短 / 数量
条件具有单调性：窗口变大条件从满足变不满足（或反过来）

4.2 不能用滑动窗口

有负数（窗口增大和不一定增大）
求子序列（不连续）
条件不单调

5 四、固定窗口大小

窗口大小固定为 k，滑动遍历：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 大小为 k 的子数组最大和
int maxSum(vector<int>& nums, int k) {
    int sum = 0;
    for (int i = 0; i < k; i++) sum += nums[i];  // 第一个窗口

    int ans = sum;
    for (int i = k; i < nums.size(); i++) {
        sum += nums[i] - nums[i - k];  // 滑一格：加新的，减出去的
        ans = max(ans, sum);
    }
    return ans;
}

6 五、题目分类速查

类型	代表题	思路
最长无重复	LeetCode 3	哈希表计数，重复就收缩
最小覆盖子串	LeetCode 76	need + window + valid
字母异位词	LeetCode 438	固定窗口，比较计数
最长重复字符替换	LeetCode 424	窗口内最多字符数 + k
水果成篮	LeetCode 904	最多两种水果，最长子数组
和为 s 的最短子数组	LeetCode 209	正整数，收缩求最短
乘积小于 K 的子数组	LeetCode 713	正数，收缩计数

7 六、解题步骤

初始化 left = 0，答案变量
遍历 right 从 0 到 n-1
右端点加入窗口，更新状态
窗口不合法时，while 循环收缩左端点
窗口合法时，更新答案

口诀：右扩左缩，边扩边更，缩完算答

Q209 长度最小的子数组

Sat, 01 Aug 2026 00:00:00 +0000

题目：给定一个含有 n 个正整数的数组和一个正整数 s，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

1 我的想法

我看到这个问题，首先发现它是连续的、并且要求区间大小，会想到用前缀和操作——前缀和可以快速求出连续元素的值，但我对它的时间复杂度了解程度不够好。

核心结论：滑动窗口如果是求值的话，右窗口滑动的同时，大概率会有某个参数要进行操作，后续进行比较从而操作左窗口，这是一个连续过程，所以题目得是连续问题。

2 简要回答

因为数组元素都是正数，可以使用滑动窗口。右指针不断扩展并累加区间和；当区间和大于等于 target 时，持续移动左指针缩短区间并更新最小长度。两个指针都只向右移动，时间复杂度是 $O(n)$。

3 详细回答

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left = 0;//左指针
        int right = 0;//右指针
        int sz = nums.size();
        int res = sz+1;
        int sum = 0;
        while(right != sz){
            sum += nums[right];
            while(sum >= target){//注意,判断left移动是一个连续过程
                res = min(res , right-left+1);
                sum -= nums[left++];
            }
            right++;
        }
        if(res == sz+1){
            return 0;
        }else{
            return res;
        }
    }
};

4 前缀和思路是否可行

可以。 设前缀和为 prefix，因为题目中的元素都是正整数，所以 prefix 严格递增。对每个左端点，可以二分查找第一个满足区间和大于等于 target 的右端点。

只用前缀和枚举左右端点：$O(n^2)$
前缀和 + 二分查找：$O(n\log n)$
滑动窗口：$O(n)$

滑动窗口更快的关键也是"元素全为正数"：右端点右移时区间和只会增大，左端点右移时区间和只会减小，因此两个指针都不需要回退。

易错或补充：比如数组 [1,1,1,1,100]，target = 100，滑动窗口的 res 初始值（sz+1）要够大，否则取不到正确答案。

滑动窗口 - 标签 - 豆浆小屋