本篇主要总结关于滑动窗口的相关做题技巧与想关例题。理论部分不会涉及。
滑动窗口模板
1.定义窗口变量——窗口需要维护的变量：数之和，最大最小长度，满足一定条件的元素个数
2.定义窗口，开始滑动——定义左右边界初始化为0，在右边界小于数组长度条件下滑动
3.扩大窗口（合法更新）——添加右边界，满足条件时更新需要维护的变量
4.收缩窗口（非法更新）—— 在滑动窗口无效或者即将无效的情况下，更新维护的变量，并且收缩滑动窗口的左边界，
如果是求子串（子数组）最短长度，在符合条件时更新维护变量和结果
如果是求子串（子数组）满足一定条件的最长子串，在收缩窗口后（刚好满足时）更新
二次更新的两种情况：
- 滑动窗口的长度是
固定的！！！ 使用if条件来更新 - 滑动窗口的长度是
可变的！！！ 使用while条件来更新
5.返回得到答案
代码模板
int func(vector<int>& nums,int k)
{
//Step1. 定义维护变量：
1. unordered_map<char,int> m; //在需要统计字符或者数字出现的次数的时候，使用哈希表
2. int sum=0,res=0; //在需要记录整数数组中的子序列和或者其他求和时，使用sum记录每一次滑动窗口的子和，再利用res得到最大的或者最小的结果
3. int len=0,start=0; //得到字符串的字串，len记录字串长度，start标识字串开始位置
//Step2. 确定滑动窗口的边界，开始滑动：
int left=0,right=0;
while (right< n) // n: 数组长度
{
//Step3. 合法更新：每进行一次滑动时，必须要更新的变量：如Step1的哈希表，sum,res,len与start等等
......
if (满足条件) //满足某一种条件：例如滑动窗口的长度：right-left+1 与某个值相等时，则进行一次判断，保存临时结果
{
//更新：res=max(res,sum) ......
}
//Step4: 非法更新
//(1): 滑动窗口的长度不固定：使用while来更新窗口
while (right-left+1 > m.size())//举个例子：无重复字符的最长字串，你的窗口长度大于哈希表的长度，则一定含有重复元素，因此更新左边界，使用while
{
.....
}
//(2)： 滑动窗口的长度固定，使用if来更新窗口
if (right>=k-1)//举个例子：子数组的最大平均值，子数组规定长度不能超过k，因此滑窗长度固定
{
.....
}
// 求最大长度，最大数目，刚好满足时在此更新结果
right++;//此处可以改为for循环
}
return res;//Step5: 返回结果
}
经典例题
1. 无重复字符的最长字串
Step4： 滑动窗口不具有固定长度，所以使用while循环来更新滑动窗口
class Solution {
public:
int lengthOfLongestSubstring(string s) {
//1. 确定维护变量：存储字符个数的哈希表
unordered_map<char,int> m;
int maxLen = 0;
//2. 定义滑动窗口的边界，开始滑动窗口
int n = s.size();
int left = 0, right = 0;
while (right < n)
{
//3. 合法更新：哈希表存储字符的更新，字符放到哈希表中
m[s[right]]++;
//4. 非法更新：窗口的长度大于哈希表的长度
//窗口里有重复的单词，非法了，需要更新窗口的左边界，必要时删除此字符，删除时边长不增，不需要更新变量maxLen
while (right - left + 1 > m.size())
{
m[s[left]]--;
if (m[s[left]] == 0) {
m.erase(s[left]);
}
left++;
}
// 收缩窗口后刚好无重复更新结果
if (right-left+1 == m.size()) {// 区间长度等于元素个数，说明不重复，符合条件
maxLen=max(maxLen, right-left+1);
}
right++;
}
//5. 返回结果
return maxLen;
}
};
2. 子数组最大平均数 I
Step4：滑动窗口的长度固定：为k ，使用 if条件来更新滑动窗口
class Solution {
public:
double findMaxAverage(vector<int>& nums, int k) {
//1. 定义维护变量
int sum = 0;
int res = INT_MIN;
//2. 确定滑动窗口的左右边界，开始滑动窗口
int left = 0, right = 0;
int n = nums.size();
while (right < n)
{
//3. 合法更新：滑动每一步，只要滑动的长度等于k，则记录一下此时的sum值
sum += nums[right];
if (right - left + 1 == k)
{
res = max(res,sum);
}
//4. 非法更新：滑动窗口的长度固定，使用if来更新，
if (right > k-1)
{
sum -= nums[left];
left++;
}
// 收缩窗口后刚好长度为k
if (right - left + 1 == k) {
res = max(res,sum);
}
right++;
}
return static_cast<double>(res) / k;
}
};
3. 至多包含两个不同字符的最长子串
//至多包含两个不同字符的最长字串
class Solution_159 {
public:
int lengthOfLongestSubstringTwoDistinct(string s) {
//1. 定义维护变量
unordered_map<char, int> m;
int maxLen = 0;
//2. 确定窗口的左右边界，开始滑动窗口
int left = 0, right = 0;
int n = s.size();
while (right < n)
{
//3. 合法更新：滑动过程中map存储每一个字符
m[s[right]]++;
//4. 非法更新：最多存储两个不同的字符，但是对于每种字符的存储数量没有限制，因此可以存储很多很多，但是不能超过两种，所以滑动窗口的长度不固定 使用while来更新滑动窗口
// 哈希表的长度大于3，则至少出现了3种不同的字符，因此窗口不合法， 需要更新
while (m.size() > 2) // right >= k-1
{
m[s[left]]--;
if (m[s[left]] == 0)
{
m.erase(s[left]);
}
left++; // 收缩窗口
}
if (m.size() <= 2)
{
maxLen = max(maxLen, right - left + 1);
}
right++;
}
return len;
}
};
4. 长度最小的子数组
class Solution {
public:
int minSubArrayLen(int target, vector<int>& nums) {
int sum = 0;
int maxLen = INT_MAX;
int left = 0, right = 0;
int n = nums.size();
while (right<n)
{
//3. 合法更新，窗口滑动一下，把这个数字相加，计算之和
sum += nums[right];
//4. 非法更新（二次更新）：当sum满足条件时，试探是否有更好的办法可以实现，即缩小窗口，有没有长度更小的子数组满足>=target
while (sum >= target)
{
maxLen = min(maxLen, right - left+1);
sum -= nums[left];
left++;
}
right++;
}
return (maxLen == INT_MAX) ? 0 : maxLen;
}
};
5.删除子数组的最大得分
实际就是无重复子数组的最大元素之和
class Solution {
public:
int maximumUniqueSubarray(vector<int>& nums) {
unordered_map<int,int> m;
int sum = 0;
int res = 0;
int left = 0, right = 0;
int n = nums.size();
while (right<n)
{
//3. 合法更新： sum每次相加,并且记录当前字符的种类，如果字符种类等于滑动窗口的长度，则滑动窗口出现的字符种类都等于哈希表里存储的种类，满足条件，相加，保存结果
m[nums[right]]++;
sum += nums[right];
if (right-left+1 == m.size())
{
res=max(res,sum);
}
//4. 非法更新： 滑动窗口长度大于哈希表的长度
//说明滑动窗口里有重复元素出现，则左边界收缩，哈希表删除左边界元素，进行窗口的更新
while (right-left+1 > m.size())
{
sum -= nums[left];
m[nums[left]]--;
if (m[nums[left]] == 0)
{
m.erase(nums[left]);
}
left++;
}
if (right-left+1 == m.size())
{
res=max(res,sum);
}
right++;
}
return res;
}
};
6.找到字符串中所有字母异位词
class Solution {
private:
unordered_map<char,int> m_s;
unordered_map<char,int> m_p;
public:
vector<int> findAnagrams(string s, string p) {
for (auto& x:p)
{
m_p[x]++;
}
int left=0,right=0;
int n1=s.size();
int n2=p.size();
vector<int> vec;
while (right < n1)
{
//3. 合法更新： 窗口滑动，字符存储入哈希表
m_s[s[right]]++;
//4. 非法更新：滑动窗口有固定长度，长度为p的长度，因此使用if条件来维护
if (right > n2 - 1)
{
m_s[s[left]]--;
if (m_s[s[left]]==0)
{
m_s.erase(s[left]);
}
left++;
}
//当哈希表的元素存储和目标p完全一致。则left起始下标就是一个目标下标
if (m_s == m_p)
{
vec.push_back(left);
}
right++;
}
return vec;
}
};
7.最小覆盖子串
76. 最小覆盖子串
m_t哈希表存储要覆盖的字符串t的字符
m_s存储滑动窗口每次滑动时添加的字符及次数
判断m_s是否含有m_t，即s字符串包含t字符串，如果它包含，那么进行接下来的二次更新
二次更新：左边界left右移，m_s哈希表存储的这个left字符计数减一，为0时则直接删除，进而达到缩小窗口的目的。同时，每缩小一次，我们记录此时的长度len和开始位置start，我们的len要取得每次的最小值，则len就是最小覆盖子串的长度，start就是其起始下标。
class Solution {
private:
unordered_map<char, int> m_s;
unordered_map<char, int> m_t;
public:
bool check()
{
for (auto& x : m_t)
{
if (m_s[x.first] < x.second)
{
return false;
}
}
return true;
}
string minWindow(string s, string t) {
//1. 确定维护的变量，是一个哈希表，存储t中的字符
for (auto& x : t)
{
m_t[x]++;
}
string res;
int len = INT_MAX; //记录字符串长度
int start = -1; //目标字符串序列位置
//2. 定义滑动窗口边界，开始滑动窗口
int left = 0, right = 0;
int n = s.size();
while (right < n)
{
//3. 合法更新：滑动窗口每移动一次，字符就放进哈希表中
m_s[s[right]]++;
//4. 非法更新:无固定长度，使用while循环，每次使得t串能够包含于s串中
//并且要尽量让s串取到《最小包含》，因此每次都更新左边界，试探是否有最小的包含，并且更新滑动窗口
while (check() && left <= right)
{
if (right - left + 1 <= len)
{
len = right - left + 1;
start = left;
}
m_s[s[left]]--;
if (m_s[s[left]] == 0)
{
m_s.erase(s[left]);
}
left++;
}
right++;
}
//5. 返回结果
return (start == -1) ? "" : s.substr(start, len);
}
};
方法二
class Solution {
public:
string minWindow(string s, string t) {
//1. 确定维护的变量，是一个哈希表，存储窗口中的字符
unordered_map<char, int> m_t; // 记录t中字符
unordered_map<char, int> m_s; // 维护窗口中字符
int cnt = 0; // 窗口中满足个数大于等于t中字符的字符个数
int start = -1, len = INT_MAX;// 子串开始和长度
for (auto i : t) {
m_t[i]++;
}
//2. 定义滑动窗口边界，开始滑动窗口
int l = 0, r = 0;
while(r < s.size()) {
//3. 合法更新：滑动窗口每加入一个t中元素，就加入哈希表，每等于t中元素，符合条件的字符数加一
if (m_t.find(s[r]) != m_t.end()) {
m_s[s[r]]++;
if (m_s[s[r]] == m_t[s[r]]) {
cnt++;
}
}
//4. 非法更新:无固定长度，使用while循环，每次使得t串能够包含于s串中
// 当满足不小于t中字符个数的字符数等于t中字符数时可以覆盖
while(cnt == m_t.size()) { //
if (r - l + 1 < len) {// 可以覆盖时更新长度和起始位置
len = r - l + 1;
start = l;
}
// 左边是t中字符时，如果即将删除的字符的数目刚好和t中对应字符字符数相等，删除后就不相等了，需要减一
if (m_t.find(s[l]) != m_t.end()) {
if (m_s[s[l]] == m_t[s[l]]) {
cnt--;
}
m_s[s[l]]--;
if (m_s[s[l]] == 0) {
m_s.erase(s[l]);
}
}
l++;
}
r++;
}
return len == INT_MAX ? "" : s.substr(start, len);
}
};8. 字符串的排列
class Solution {
public:
bool checkInclusion(string s1, string s2) {
unordered_map<char,int> m_s1;
unordered_map<char,int> m_s2;
for (auto& x:s1)
{
m_s1[x]++;
}
int left=0,right=0;
int n1 = s1.size();
int n2 = s2.size();
while (right < n2)
{
//3. 合法更新：存储字符串到哈希表中，然后与目标哈希表存储元素进行比较
m_s2[s2[right]]++;
//4. 非法更新：滑动窗口长度固定，更新维护变量，缩短左边界
if (right > n1-1) // 此后都是减一加一
{
m_s2[s2[left]]--;
if (m_s2[s2[left]]==0)
{
m_s2.erase(s2[left]);
}
left++;
}
if (m_s2 == m_s1)
{
return true;
}
right++;
}
return false;
}
};
9. 乘积小于K的子数组数目
class Solution {
public:
int numSubarrayProductLessThanK(vector<int>& nums, int k) {
int res = 0;
//1. 确定维护的变量，乘积结果
int cst = 1;
//2. 定义滑动窗口边界，开始滑动窗口
int left = 0, right = 0;
int n = nums.size();
while (right < n)
{
//3. 合法更新：滑动窗口每移动一次，就乘一次
cst *= nums[right];
//4. 非法更新:无固定长度，使用while循环，乘积大于等于k时收缩窗口
while (left <= right && cst >= k)
{
cst /= nums[left];
left++;
}
// 满足条件，更新结果
if (cst < k)
{
res += right - left + 1;
}
right++;
}
//5. 返回结果
return res;
}
};
2903
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
