本文介绍了滑动窗口算法，这是一种常见的数组问题求解方法，常用于优化暴力解法。文章通过讲解解题思路，包括如何证明滑动窗口的单调性以及窗口中需要维护的内容，帮助读者理解滑动窗口的本质。同时，提供了四个LeetCode难题的实例，包括替换后的最长重复字符、找到字符串中所有字母异位词、滑动窗口中位数和最小区间，详细分析了每个问题的解题代码和时间复杂度，旨在通过实战提升读者的算法能力。
前言
滑动窗口指的是这样一类问题的求解方法，在数组上通过双指针同向移动而解决的一类问题。其实这样的问题我们可以不必为它们专门命名一个名字，它们的解法其实是很自然的。
本质：使用滑动窗口解决的问题通常是暴力解法的优化，掌握这一类问题最好的办法就是练习，然后思考清楚为什么可以使用滑动窗口。
滑动窗口
一、解题方法
滑动窗口基于暴力算法
1、如何暴力？
2、如何证明滑动窗口的单调性？
3、窗口中需要维护什么？
4、时间复杂度分析？
二、题目练习
1.替换后的最长重复字符（leetcode424题-medium）
题目描述
给你一个仅由大写英文字母组成的字符串，你可以将任意位置上的字符替换成另外的字符，总共可最多替换 k 次。在执行上述操作后，找到包含重复字母的最长子串的长度。
注意：字符串长度 和 k 不会超过
1
0
4
10^4
104。
示例 1：
输入：s = "ABAB", k = 2
输出：4
解释：用两个'A'替换为两个'B',反之亦然。
示例 2：
输入：s = "AABABBA", k = 1
输出：4
解释：
将中间的一个'A'替换为'B',字符串变为 "AABBBBA"。
子串 "BBBB" 有最长重复字母, 答案为 4。
解题代码：
class Solution {
public:
int characterReplacement(string s, int k) {
int res = 0;
for (char c = 'A'; c <= 'Z'; c ++ ){ // 暴力枚举
for (int i = 0, j = 0, cnt = 0; i < s.size(); i ++ ){ // 滑动右边界
if (s[i] == c) cnt ++ ;
while (i - j + 1 - cnt > k){ // 不满足题意滑动左边界调整
if (s[j] == c) cnt -- ;
j ++ ;
}
res = max(res, i - j + 1);
}
}
return res;
}
};
2.找到字符串中所有字母异位词(leetcode438题-medium)
给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。 异位词 指字母相同，但排列不同的字符串。 示例 1:输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。
输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。
1 <= s.length, p.length <= 3 * 104
s 和 p 仅包含小写字母
class Solution {
public:
vector<int> findAnagrams(string s, string p) {
unordered_map<char, int> hash;
for (auto &x : p) hash[x] ++ ;
int allkinds = hash.size(); //目标字符的种类
vector<int> res;
for (int i = 0, j = 0, kinds = 0; i < s.size(); i ++ ){ //窗口[j, i]
if (-- hash[s[i]] == 0) kinds ++ ; //窗口内某一种是全在的
while (i - j + 1 > p.size()){
if (hash[s[j ++ ]] ++ == 0) kinds -- ; // 删除窗口字符
}
if (kinds == allkinds) res.push_back(j); // 是否完全匹配
}
return res;
}
};
时间复杂度：
O
(
n
)
O(n)
O(n)，
n
n
n是字符串
s
s
s长度。
空间复杂度：
O
(
m
)
O(m)
O(m)，
m
m
m是字符串
p
p
p的长度。
3.滑动窗口中位数 (leetcode480-hard)
中位数是有序序列最中间的那个数。如果序列的长度是偶数，则没有最中间的数；此时中位数是最中间的两个数的平均数。
例如：
[2,3,4]，中位数是 3
[2,3]，中位数是 (2 + 3) / 2 = 2.5
给你一个数组 nums，有一个长度为 k 的窗口从最左端滑动到最右端。窗口中有 k 个数，每次窗口向右移动 1 位。你的任务是找出每次窗口移动后得到的新窗口中元素的中位数，并输出由它们组成的数组。
示例：
给出 nums = [1,3,-1,-3,5,3,6,7]，以及 k = 3。
窗口位置 中位数
--------------- -----
[1 3 -1] -3 5 3 6 7 1
1 [3 -1 -3] 5 3 6 7 -1
1 3 [-1 -3 5] 3 6 7 -1
1 3 -1 [-3 5 3] 6 7 3
1 3 -1 -3 [5 3 6] 7 5
1 3 -1 -3 5 [3 6 7] 6
因此，返回该滑动窗口的中位数数组 [1,-1,-1,3,5,6]。
提示：
你可以假设 k 始终有效，即：k 始终小于等于输入的非空数组的元素个数。
与真实值误差在 10 ^ -5 以内的答案将被视作正确答案。
解题代码：
class Solution {
public:
vector<double> medianSlidingWindow(vector<int>& nums, int k) {
vector<double> res;
multiset<int> S; //使用元素可重复的红黑树维护窗口
for (int i = 0, j = 0; i < nums.size(); i ++ ){ //开始滑动
S.insert(nums[i]);
while (i - j + 1 > k) S.erase(S.lower_bound(nums[j ++ ])); //窗口太大，擦除s[j], 这里的擦除会不会把窗口中的值为s[j]的全部删除。
if (i - j + 1 == k){ //达到窗口大小开始计算
// 求链表中点
auto bg = S.begin();
if (k % 2 == 0){
int len = k / 2 - 1;
while (len -- ) bg ++ ;
double val = *bg;
bg ++ ;
val = (val + *bg) / 2;
res.push_back(val);
}else{
int len = k / 2;
while (len -- ) bg ++ ;
double val = *bg;
res.push_back(val);
}
}
}
return res;
}
};
时间复杂度：
O
(
n
l
o
g
k
)
O(nlogk)
O(nlogk)
空间复杂度：
O
(
1
)
O(1)
O(1)
4.最小区间(leetcode632-hard)
你有 k 个 非递减排列 的整数列表。找到一个 最小 区间，使得 k 个列表中的每个列表至少有一个数包含在其中。 我们定义如果 b-a < d-c 或者在 b-a == d-c 时 a < c，则区间 [a,b] 比 [c,d] 小。 示例 1：输入：nums = [[4,10,15,24,26], [0,9,12,20], [5,18,22,30]]
输出：[20,24]
解释：
列表 1：[4, 10, 15, 24, 26]，24 在区间 [20,24] 中。
列表 2：[0, 9, 12, 20]，20 在区间 [20,24] 中。
列表 3：[5, 18, 22, 30]，22 在区间 [20,24] 中。
输入：nums = [[1,2,3],[1,2,3],[1,2,3]]
输出：[1,1]
输入：nums = [[10,10],[11,11]]
输出：[10,11]
示例 4：
输入：nums = [[10],[11]]
输出：[10,11]
示例 5：
输入：nums = [[1],[2],[3],[4],[5],[6],[7]]
输出：[1,7]
提示：
nums.length == k
1 <= k <= 3500
1 <= nums[i].length <= 50
-105 <= nums[i][j] <= 105
nums[i] 按非递减顺序排列
解题代码：
class Solution {
public:
vector<int> smallestRange(vector<vector<int>>& nums) {
int n = nums.size();
unordered_map<int, vector<int>> hash;
int xMin = INT_MAX, xMax = INT_MIN;
for (int i = 0; i < n; i ++ )
for (auto &x : nums[i]){
hash[x].push_back(i);
xMin = min(x, xMin);
xMax = max(x, xMax);
}
// 滑动窗口需要维护的内容
int kinds = 0;
vector<int> freq(n);
int left = xMin, right = xMin - 1;
int bestLeft = xMin, bestRight = xMax;
while (++ right <= xMax){ // 直到右区间滑到终点时
if (hash.count(right)) {
for (const int& x: hash[right]) {
++freq[x];
if (freq[x] == 1) {
++ kinds;
}
}
while (kinds == n) {
if (right - left < bestRight - bestLeft) {
bestLeft = left;
bestRight = right;
}
if (hash.count(left)) {
for (const int& x: hash[left]) {
--freq[x];
if (freq[x] == 0) {
--kinds;
}
}
}
++ left;
}
}
}
return {bestLeft, bestRight};
}
};
时间复杂度：
O
(
k
n
+
V
)
O(k n + V)
O(kn+V)，
k
n
=
s
i
z
e
o
f
(
n
u
m
s
)
kn = sizeof(nums)
kn=sizeof(nums)，
V
V
V是值域
[
x
M
i
n
,
x
M
a
x
]
[xMin,xMax]
[xMin,xMax]。
空间复杂度：
O
(
k
)
O(k)
O(k)，
f
r
e
q
freq
freq数组的大小。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
