目录
本篇博客重点通过第一道题来引出滑动窗口算法，并且展开讲解滑动窗口算法的使用场景与原理
滑动窗口也是有模板的，但是不建议大家死记模板，而是要理解滑动窗口的原理，此类题目最重要的问题不是如何使用滑动窗口，而是由暴力解法一步步优化后发现"同向双指针"规律之后，得出可以用滑动窗口来解题~
leetcode/牛客 题目
一、长度最小的子数组
209. 长度最小的子数组 - 力扣（LeetCode）
https://leetcode.cn/problems/minimum-size-subarray-sum/1.题目解析
找出给定正整数数组中 所有满足 子数组的和 >= 目标值 target的 长度最小的子数组，返回该子数组的长度
2.解法分析
暴力解法:
暴力枚举所有子数组的和, 两个下标标记一段区间，第三个下标遍历求和 --- O(N^3)
优化策略:
定义变量sum保存一段子数组的和, sum每次+= right位置的数字, 判断target与sum的大小关系， 然后right右移动
优化1: 当sum >= target后，right就不用继续向后移动了，因为数组中的元素都是正整数，所以往后sum继续加, 只会比target更大，子数组长度更长，不是最终结果
优化2:当sum >= target后，此时left右移，right不用再回退到left的位置了，因为刚才的sum已经保存了一段区间的值，left右移之后，只需要sum-=2即可
上面两个优化之后，本质就是滑动窗口(形象理解，就是一段区间在往后滑动)，滑动窗口本质就是同向双指针，也就是两个指针都不回退，只要能在题目中发现两个指针不回退，基本就是使用滑动窗口来解决问题了~
滑动窗口算法步骤:
1.初始化指针，left=0, right=0
2.进窗口 （本题是sum += nums[left]）
3.判断 (本题是判断sum是否>=target, >=就更新结果)
4.出窗口
注意:
1. 2、3、4是循环操作
2. 更新结果就题论题，可能是在判断之后就更新结果，也可能是在出窗口之后更新结果
3. 代码写出来是两层for循环，但实际left和right最多都遍历了数组一遍，所以是O(N)
3.算法代码
class Solution {
public:
int minSubArrayLen(int target, vector<int>& nums) {
int sum = 0;
int n = nums.size();
int length = INT_MAX; //length开始直接给int最大值，后续求min一定不会出错
for(int left = 0, right = left; right < n; right++)
{
sum += nums[right]; //进窗口
while(sum >= target)//判断
{
length = min(length, right - left + 1); //更新结果
sum -= nums[left++]; //出窗口
}
}
return length == INT_MAX ? 0 : length; //没有符合题意的就返回0
}
};二、无重复字符的最长子串
找出一个字符串中不包含重复字符的最长子串的长度
2.解法分析
暴力解法: 以每一个字符为起始，向后遍历，遇到有重复的字符就停止，就可以求出开始字符为起始的不包含重复字符的子串长度, 然后再从下一个字符开始，继续上述过程
其中，借助 哈希表 这个数据结构 判断遍历过程是否有重复字符
滑动窗口解法:
遇到重复字符之后，如果是暴力解法，left应该++，来到e的位置，然后right回退到e的后面一个位置，但是right继续往后走还是会遇到刚才的a, 此时又重复了，而且子串长度还变小了，所以right遇到重复字符之后，我们不要让left++到下一个位置，left应该直接跳过下标为2的字符a; left跳过字符a之后，right也没有必要回退了，因为left已经跳过重复字符了，所以right直接从刚才的位置继续向后移动即可!
所以整个过程left和right同向移动, 使用滑动窗口解决问题~
3.算法代码
class Solution {
public:
int lengthOfLongestSubstring(string s) {
unordered_map<char, int> map;
int len = 0;
for(int left = 0, right = left; right < s.size(); right++)
{
map[s[right]]++; //进窗口
while(map[s[right]] > 1) //判断
map[s[left++]]--; //出窗口
len = max(len, right-left+1); //更新结果
}
return len;
}
};三、最大连续1的个数III
1004. 最大连续1的个数 III - 力扣（LeetCode）https://leetcode.cn/problems/max-consecutive-ones-iii/description/1.题目解析
这道题的关键就是将原题目的翻转操作进行转化, 题目说最多翻转k个0, 然后返回数组中连续1的最大个数，可以转化成找出含0个数不超过k个的最长的子数组
2.解法分析
暴力解法: 暴力枚举 + 统计0个数的计数器
滑动窗口:
当zero个数>k时，不满足要求了，left++, 如果是暴力枚举，right要回退到left的位置，此时right依旧往后++， 仍然会出现刚才的情况，并且此时1的个数更少了；因此right无需回退，直接让left++， 直到让left和right所构成的区间内满足0的个数不超过k个， 此时right继续往后++就行
至此就出现了“同向双指针”，就可以使用滑动窗口解决问题了！
3.算法代码
class Solution
{
public:
int longestOnes(vector<int>& nums, int k)
{
int ret = 0; //满足题意的子数组的最长长度
int zero = 0; //统计0出现的个数
for(int left = 0, right = left; right < nums.size(); right++)
{
if(nums[right] == 0) zero++; //进窗口
while(zero > k) //判断
if(nums[left++] == 0) zero--; //出窗口
ret = max(ret, right-left+1); //更新结果
}
return ret;
}
};四、将x减到0的最小操作数
本题直接正面做比较难，我们采用正难则反的思路解决
假设整个数组的总和为sum
反向思路: 求数组中和为sum-x的最长子数组
2.算法分析
本题用反向思路转化之后和本篇博客的题目1分析过程就基本一样了！
记sum-x为target, 为了方便表示，重新定义一个变量sum表示子区间的长度和
如下图所示，当sum>=target后, left来到下一个位置，此时right不用回退，因为上图所示sum<target, left现在还后移了一位(下图所示)，如果right回退，之后仍会走到上图所示位置，整个过程 sum仍然<target, 依旧不会是最终结果
因此right就不要回退了， left来到下图位置之后，right++即可！
至此就出现了“同向双指针”，就可以使用滑动窗口解决问题了！
3.算法代码
class Solution {
public:
int minOperations(vector<int>& nums, int x)
{
int sum = 0;
for(int e : nums) sum += e; //求数组中所有元素的和
int target = sum - x;
if(target < 0) return -1; //细节问题
int ret = -1;
int s = 0; //记录子区间的和
for(int left = 0, right = 0;right < nums.size(); right++)
{
s += nums[right]; //进窗口
while(s > target) //判断
s -= nums[left++]; //出窗口
if(s == target) //只有s==target才更新结果
ret = max(ret, right - left + 1); //更新结果
}
if(ret == -1) return ret;
else return nums.size()-ret;
}
};
五、水果成篮
904. 水果成篮 - 力扣（LeetCode）https://leetcode.cn/problems/fruit-into-baskets/1.题目解析
题目条件比较多，但是抽丝剥茧完之后，我们可以将题目问题转化一下
1. 找出一个最长的子数组的长度(水果的最大数目)
2. 子数组中不能超过两种类型的水果(只有两个篮子,每个篮子只能装一种水果)
2.算法分析
暴力解法: 暴力枚举，每次从一个下标开始，向后遍历到子数组超过2种类型的水果为止
滑动窗口：
当left和right所维护的区间内的水果种类等于两种时，right就停下来，然后left++,此时区间内少了一个水果，如果这个水果在新的left-right区间存在，那么kinds依旧=2， 但是如果不存在, kinds就是1了，无论哪种情况,right都没必要回退了，因为回退之后right依旧会++到刚才的位置！
至此就出现了“同向双指针”，就可以使用滑动窗口解决问题了！
3.算法代码
class Solution {
public:
int totalFruit(vector<int>& fruits)
{
unordered_map<int, int> hash; //哈希表统计某种水果出现的次数
int ret = 0; //记录最终结果
for(int left = 0, right = 0; right < fruits.size(); right++)
{
hash[fruits[right]]++; //进窗口
while(hash.size() > 2)
{
hash[fruits[left]]--; //出窗口
if(hash[fruits[left]] == 0)
hash.erase(fruits[left]);
left++;
}
ret = max(ret, right-left+1); //更新结果
}
return ret;
}
};哈希表频繁的插入与删除数据，效率就会有些低，因此我们可以用数组模拟哈希表！
优化代码
class Solution {
public:
int totalFruit(vector<int>& fruits)
{
int hash[100001] = {0}; //模拟哈希表统计某种水果出现的次数
int kinds = 0; //记录子区间内水果种类数
int ret = 0; //记录最终结果
for(int left = 0, right = 0; right < fruits.size(); right++)
{
if(hash[fruits[right]] == 0) kinds++;
hash[fruits[right]]++; //进窗口
while(kinds > 2)
{
hash[fruits[left]]--; //出窗口
if(hash[fruits[left]] == 0) kinds--;
left++;
}
ret = max(ret, right-left+1); //更新结果
}
return ret;
}
};六、找到字符串中所有字母异位词
438. 找到字符串中所有字母异位词 - 力扣（LeetCode）https://leetcode.cn/problems/find-all-anagrams-in-a-string/1.题目解析
求s串中所有p的异位词子串, 返回起始下标
2.算法分析
2.1 如何判断字母异位词
p2串中每个字符出现个数 和 p1串对应每个字符出现的次数相等，p2串就是p1串的字母异位词
2.2 暴力解法
s = "cbaebabacd", p="abc"
先求出p串长度m，然后用一个哈希表统计出p串中每个字符出现的次数
然后遍历s串，每次固定一个下标i，right指针从i开始向后遍历共m个字符停止，遍历过程中同时用另一个哈希表统计每个字符的个数，和第一个哈希表进行对比, 如果两哈希表相等就更新结果
下一轮清空哈希表，i++, right回退到 i 的位置，继续向后遍历统计个数
2.3 滑动窗口
如2.2所示，right指针其实没有必要回退，因为回退之后还要把已经统计过的字符重新统计一遍，所以不用回退，下一轮从哈希表中删除i位置字符，right++, 继续遍历统计即可
至此就出现了“同向双指针”，就可以使用滑动窗口解决问题了！不过之前题目的滑动窗口大小是不固定的，本题滑动窗口是固定的~
本题滑动窗口解题步骤
1.left = 0, right = 0;
2.进窗口 hash[in] ++ (in代表要进窗口的字符)
3.判断 right-left+1>m (m代表p串长度)
4.出窗口 hash2[out]-- (out代表要出窗口的字符)
5.更新结果 check(hash2, hash1) 先要检查两个哈希表是否相等
2.4 优化两个哈希表相等的判断方法
2.3中更新结果时需要检查两个哈希表是否相等，正常的思路可以遍历一遍哈希表(本题s/p串都是小写字母，遍历26次即可), 但是如果s/p中存的不只是小写字母比较起来就比较麻烦了~
优化方法: 利用变量 count 来统计窗口中 "有效字符"的个数
ps:上图中p串对应的哈希表记成了hash2, s串对应的哈希表记成了hash1, 代码刚好反过来了，大家重点看原理就行~
总结：
1.有效字符指的是哈希表1中的字符对应的个数<=哈希表2中的字符对应的个数
2.count变量需要在以下步骤中使用:
1.字符进窗口后要判断一下该字符是否是有效字符，是有效字符，count就++
2.字符出窗口前要判断一下该字符是否是有效字符，是有效字符，count就--
3.更新结果时判断一下count与p串长度m是否相等即可, 相等就更新
3. 算法代码
class Solution {
public:
vector<int> findAnagrams(string s, string p)
{
vector<int> ret; //存储结果
int count = 0; //维护窗口中"有效字符"的个数
int m = p.size(); //p串长度
int hash1[26] = {0}; //统计字符串p中每个字符出现的个数
for(auto& e : p) hash1[e-'a']++;
int hash2[26] = {0}; //统计窗口内每个字符出现的个数
for(int left = 0, right = 0; right < s.size(); right++)
{
char in = s[right];
hash2[in -'a']++; //进窗口
if(hash2[in - 'a'] <= hash1[in - 'a']) count++; //是有效字符,count就++
if(right-left+1 > m) //判断
{
char out = s[left++];
if(hash2[out - 'a'] <= hash1[out - 'a']) count--; //是有效字符,count就--
hash2[out - 'a']--; //出窗口
}
if(count == m)
ret.push_back(left); //更新结果
}
return ret;
}
};七、串联所有单词的子串
这道题目本质就是题目六的变形， 但区别在于，题目六求字母异位词本质求的是字母的全排列组合，而本道题相当于求的是单词的排列组合情况, 但如果我们把每个单词看成一个整体，将s串进行划分，本质就和题目六一样了！
2.解法分析
本题与题目六的不同:
1.题目六我们使用数组模拟哈希表，因为映射关系是字符和int映射，而本道题是字符串和int映射，因此需要用到unordered_map<string, int>
2.left与right指针的移动, 题目六 进窗口 / 出窗口 left/right只需要移动一位， 但是本题进窗口/出窗口是针对单词，因此 left/right 移动的步长 是单词的长度
3.滑动窗口执行的次数
p串的划分方式不唯一，还有以下几种, 因此滑动窗口也要执行 单词的长度 次
3.算法代码
class Solution {
public:
vector<int> findSubstring(string s, vector<string>& words)
{
vector<int> ret; //记录最终结果
unordered_map<string, int> hash1; //保存words中每个单词的个数
for(auto& e : words) hash1[e]++; //求words中每个单词对应的频次, 映射进哈希表
int len = words[0].size(); //每个单词的长度
int m = words.size(); //单词的个数
for(int i = 0; i < len; i++) //滑动窗口执行len次
{
unordered_map<string, int> hash2; //维护窗口内单词的频次
//注意循环条件不是right小于s.size(), 因为进入循环后还要取子串, 如果只是小于s.size(), 可能会越界
for(int left = i, right = i, count = 0; right + len <= s.size(); right += len)
{
string in = s.substr(right, len);
hash2[in]++; //进窗口
//如果in在hash1中不存在，那么判断时就会创建in放入哈希表, 非常耗时, 因此先判断一下~
if(hash1.count(in) && hash2[in] <= hash1[in]) count++; //有效单词, count++
if(right - left + 1 > len * m) //判断
{
string out = s.substr(left, len);
if(hash1.count(out) && hash2[out] <= hash1[out]) count--; //有效单词，count--
hash2[out]--; //出窗口
left += len;
}
if(m == count) ret.push_back(left); //更新结果
}
}
return ret;
}
};八、最小覆盖子串
76. 最小覆盖子串 - 力扣（LeetCode）https://leetcode.cn/problems/minimum-window-substring/1.题目解析
在s串中求一段长度最小的子串，该子串能够覆盖t串所有字符
2.解法分析
2.1 暴力解法: 暴力枚举+哈希表
每次从1个下标开始，往后枚举，枚举p中的所有字符在该区间内都出现了就停下来，统计长度
2.2 滑动窗口:
至此就出现了“同向双指针”，就可以使用滑动窗口解决问题了！
2.3 本题滑动窗口步骤
1.left=0, right=0
2.进窗口 hash2[in]++
3.判断 check(hash1, hash2) 通过哈希表检查当前子串是否能覆盖t串
4.更新结果(判断当前区间长度是否 < 之前记录的满足题意的最小区间长度)
5.出窗口 hash2[out]--
注意:本题的更新结果在出窗口之前更新, 因为出窗口的条件和之前不太一样，本题是找到了覆盖t串的子串就出窗口，继续判断，所以在出窗口之前需要更新结果
2.4 优化检查两个哈希表的策略
上述通过哈希表检查当前子串是否能够覆盖t串还是比较麻烦的，要遍历两个哈希表~
优化方法:使用 count 变量标记有效字符的 种类
总结：
1.有效字符是指 s串中的字符个数 >= t串中对应字符的个数 该字符就是有效字符
注意: 更新count的条件是 hash1[字符] == hash2[字符], 如果>= 或者 <= 就统计会导致重复统计
2.count变量需要在以下步骤中使用:
1.字符进窗口后要判断一下该字符是否是有效字符，是有效字符，count就++
2.字符出窗口前要判断一下该字符是否是有效字符，是有效字符，count就--
3.判断是否要进入 更新结果+出窗口 的代码 时比较count与hash1.size()的大小，相等进入 更新结果+ 出窗口 的代码
3.算法代码
class Solution {
public:
string minWindow(string s, string t)
{
int hash1[128] = {0};
int kinds = 0; //统计t串中有效字符的种类(因为我们使用数组模拟哈希表，因此无法直接得知t串有效字符的种类)
for(auto ch : t)
if(hash1[ch]++ == 0) kinds++;
int hash2[128] = {0}; //统计窗口内每个字符的频次
int minlen = INT_MAX, begin = -1; //知道起始位置和长度就可以拿到符合要求的子串
for(int left = 0, right = 0, count = 0; right < s.size(); right++)
{
char in = s[right];
hash2[in]++; //进窗口
if(hash2[in] == hash1[in]) count++; //有效字符, count++
while(count == kinds) //判断
{
//更新结果
if(right - left + 1 < minlen)
{
minlen = right - left + 1;
begin = left;
}
char out = s[left++];
if(hash2[out] == hash1[out]) count--; //有效字符, count--
hash2[out]--; //出窗口
}
}
if(begin == -1) return ""; //不存在满足题意的结果
else return s.substr(begin, minlen);
}
};
九、F -dd爱框框
F-dd爱框框_牛客小白月赛34 (nowcoder.com)https://ac.nowcoder.com/acm/contest/11211/F1.题目解析
求数组的一段区间，求出一个最短的区间，使得该区间元素之和 >= x, 若存在相同长度的区间，输出l最小的那个
2.算法分析
暴力解法 ---> 滑动窗口
3.算法代码
#include <iostream>
using namespace std;
#include <vector>
int main()
{
int n, x;
cin >> n >> x;
vector<int> arr(n+1);
for(int i = 1; i <= n; i++)
cin >> arr[i];
int l = 0, r = 0; //最终区间的左右端点
int retlen = n;
for(int left = 1, right = 1, sum = 0; right < n; right++)
{
sum += arr[right];
while(sum >= x)
{
if(right - left + 1 < retlen)
{
l = left, r = right;
retlen = right - left + 1;
}
sum -= arr[left++];
}
}
cout << l << " " << r;
}
7554
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
