利用滑动窗口解题

目录

前言:

第一题:209. 长度最小的子数组 - 力扣(LeetCode)

 第二题:1004. 最大连续1的个数 III - 力扣(LeetCode)

第三题:3. 无重复字符的最长子串 - 力扣(LeetCode)

第四题:1658. 将 x 减到 0 的最小操作数 - 力扣(LeetCode)

第五题:904. 水果成篮 - 力扣(LeetCode)

第六题:30. 串联所有单词的子串 - 力扣(LeetCode) 

第七题: 438. 找到字符串中所有字母异位词 - 力扣(LeetCode)

 第八题:76. 最小覆盖子串 - 力扣(LeetCode)

总结:


 

前言:

本篇文章还是以先介绍题目意思,然后再解释以下算法原理,最后再是给出代码的实现。

但是与上篇文章不同的是,这篇文章回给出为什么要用滑动窗口解题,怎么想到的,以及滑动窗口的原理到底是什么。所以前两题会以最详细的方法进行说明,会先从暴力解法出发,进行一步一步的优化,从而到达其代码与滑动窗口类似,从而达到解释为什么用滑动窗口解题。

第一题:209. 长度最小的子数组 - 力扣(LeetCode)

71c07c0b4f7b450ab1570b5348bdb723.png

题目解释:

题目的意思很好理解,但是需要注意的是这里的子数组是一个连续的子数组,意思是:你只能挑选下标连续的元素,不能挑选不连续的,比如:下标0,下标2......他就不连续,所以不是子数组。

为什么要这样写?为什么要用滑动窗口?    下面以题目中的示例一为例说明。

对于一个题,看完题首先去想的应该不是最优算法,而是怎么使用暴力解法去写,然而对于这道题的暴力写法也很好写,我们只需遍历数组长度的次数(设为Len)。在每一趟中,从起始位置i开始,我们将遍历整个数组,并计算出当前的和sun。如果sun大于一个预定值sum,则更新结果,并结束本趟遍历。时间复杂度为0(n^2)

就拿示例一,我们先模拟第一趟

ea5ae741c2dc467c85cfd1d0826551fc.png

所以我们进行优化,对于每趟的遍历,如果第一次出现sum>=target的情况,则结束本趟的遍历,虽然从时间复杂度上没有太大变化,但还是优化了不少的时间的。

第一次优化完后,你肯定是很疑惑的,力扣中等题不可能这么简单吧,对,就是不这么简单,你把优化过后的代码提交,发现是过不了的,是超时的。所以我们还需要再进行优化。

我们发现没遍历一趟结束后,都需要进行sum=0,对sum进行刷新,然后再依次向后遍历到上次结束的位置。

f80492cb66994281af5b634a53f5c062.png

所以再优化暴力解法,将sum=0,去掉,然后每一趟遍历结束后,先更行结果,然后再减去左边的元素。

本次优化的结果需要将原本的暴力解法代码大致完全修改,代码写完后此时提交是可以过的。

虽然这种算法思路是我自己想出来的,并没有遵循特定的算法框架。在用暴力完成这个题目后,成就感是很高的,但其实我们并不知道这是一种什么样的算法,你对于你想出来的这个思路总的掌握来说还是不牢固的。实际上,这种思路就是滑动窗口算法。

那么下面就用本题说明下滑动窗口的算法

算法原理:

我们上面对暴力解法的优化都是对一个数组进行的操作,其操作空间类似一个可以滑动的小窗口,所以该算法就叫滑动窗口

滑动:说明窗口不是固定不变的,而是具有一定的可变性的

窗口:窗口并不是一定固定不变的,可以进行扩大,然后逐步进行缩小直到满足情况

其大致操作可以分为三步

  • 初始化left,right
  • 进窗口
  • 判断条件(一般是刚好超出题目的符合要求的边界),出窗口,是否更新结果(出窗口与判断不分先后,不同题目先后不同,根据题目分析定先后)需要注意的是可能出一个还是满足出窗口的条件,有时要用while循环出窗口,又是只是if出一次

注意不同的题目对于步骤三也会不同,可能把更新结果变为第四步,而不是放在循环里面

那么为了详细一点就那示例一模拟一下

while循环的结束条件就为right>=n。

首先就先判断,更新结果与出窗口相对位置,需要注意的是对于本题,可能出一个还是满足出窗口的条件,所以要用while循环出窗口,判断条件就为sum>=target,换句话说,就是如果当前维护的窗口的合为8,如果左边界为1,左边界出窗口后如果合依旧大于target,那么就需要再进行出窗口操作。

下面给出图解,我们省略前几步进窗口的操作,从第一次判断开始模拟

d4ee1f6faa1b42bf9facd00f35ebc891.png

给出模拟以后大致思路就很清楚了

用小图画出思路就为:

f962fcd9f4884734b3a9f37aba9b0d7d.png

代码实现:

class Solution {
public:int minSubArrayLen(int target, vector<int>& nums) {int left=0,right=0;int n=nums.size();if (n == 0) {return 0;}int sum=0;int ret=INT_MAX;while(right<n){while(right<n && sum<target){sum+=nums[right];right++;}while(left<right && sum>=target){ret=min(ret,right-left);sum-=nums[left];left++;}}return ret==INT_MAX? 0 : ret;}
};

 第二题:1004. 最大连续1的个数 III - 力扣(LeetCode)

4cbed4d35ac944fcb180df825a5a7e07.png

题目解释: 

题目也没什么好解释的,但要注意你不是一定要翻转k个0才更行结果,就比如说如果给出一个案例k=2,然后数组中只有一个0,那么反转1个然后统计所有的1,也可以作为返回值返回。

同样,我们先从暴力解法开始

暴力枚举+zero计数器

依旧分两层循环,再利用双指针。暴力枚举出所有反转k个0,统计该数组的个数。

同样跟第一题一样可以优化,在每一次遍历完成后,我们需要将右边界更新为左边界,然后继续向右移动。然而,这样的操作意味着我们会经过上一次遍历结束时的位置,从而导致重复计算。为了避免这种冗余操作,我们可以对算法进行优化。

经过这一步优化,其大致思路就与滑动窗口有点相似了,如果看完第一个讲解,那么应该很容易反应过来应该使用滑动窗口

所以我们拿出来滑动窗口的三步骤

e7f4050d2a78457399febf430c52ff96.png

我们这时候需要解决的问题就为,是先出窗口还是先更新结果。还是说更新结果放在别处,

经过思考,如果想要出窗口,那么此时的count计数器肯定是大于k的,肯定是已经翻转个数超过k,如果再循环里面更新,那么可能导致第一个出的本来就是1,所以更新要放到循环外,定为第四步。

那么对于每一步,我们再分析详细操作

对于进窗口,不变的就是进完有right++,但是如果进的是1,则无操作,如果是0则,计数器++

判断条件就为zero>k时,但要用while循环

 

 aefc9254ff8e4f86bf16598dd5d4b62b.png

 代码实现:

class Solution {
public:int longestOnes(vector<int>& nums, int k) {int n=nums.size();int ret=0;for(int right=0,left=0,zero=0;right<n;right++){if(nums[right]==0) zero++;while(zero>k){if(nums[left++] == 0) zero--;}ret=max(ret,right-left+1);}return ret;}
};

第三题:3. 无重复字符的最长子串 - 力扣(LeetCode)

cb1c1c5dec2548aba001e301ad67c5bf.png 

题目也是很好读懂的 也不需要解释

看完前两个的题目解释,那么对于本题就不在从暴力算法优化到与滑动窗口差不多思路的步骤了,

直接从滑动窗口解题

思路:

如何想到用滑动窗口   本段摘自力扣官方题解

f7343573bebb43cebe1f822ea1fbea24.png

 那么如此一来就可以使用滑动窗口来解此题了

代码实现:

同样,我们拿出滑动窗口的三步图,我们先解决出窗口与更新条件的位置关系,同样,跟第二题一样,如果再循环里面更新,那么导致第一个出后该窗口内还是存在重复的字符,所以更新要放到循环外,定为第四步。

对于进窗口就是一成不变的将其添加到窗口内。但是这里就需要考虑那么出窗口的条件呢?

需要判断是否出现重复的,跟前两题不一样了,前两题只需要根据窗口的个数或者计数器的大小,但是这如果你还去遍历窗口的话那时间复杂度要高了,还不如用暴力呢。

所以我们就需要用哈希表或者创建一个数组,其大小为26,对应着26个字母,本题就用哈希表了。

efd238ef81d94b47b751008617cab7ab.png

所以把上面的想清后,我们把每一步详细一下,就变为了下面:

e2f2af45362547cf9aaf8a52b443ac76.png 

代码实现:

class Solution {
public:int lengthOfLongestSubstring(string s) {unordered_set<char> occ;int n=s.size();if(n==0){return 0;}int ret=-1,r=-1;for(int i=0;i<n;i++){if(i!=0){occ.erase(s[i-1]);}while(r+1<n && !occ.count(s[r+1])){occ.insert(s[r+1]);++r;}ret=max(ret,r-i+1);}return ret;}
};

第四题:1658. 将 x 减到 0 的最小操作数 - 力扣(LeetCode)

89c3e3303c7d4afda8fa6ae40906173f.png

其实对于本道题,如果不明确告诉你用滑动窗口解题,那么这道题其实非常难写的。

但是换句话说,如果明确告诉你用滑动窗口去写,你能反应过来怎么去写么?

我一开始也没反应过来如何去写,也是听了听别人给的一点思路,然后想了想,才写出来的。

其实这道题正着想很难,但是如果反着想,我们把这道题改为计算合为sum-x的最大连续子数组,但返回值为n-最长连续子数组的大小。那么就很好解决了

依旧拿出滑动窗口三小步

先判断更新结果与出窗口的位置关系:更新结果在出窗口循环的外面

我们进窗口就是tmp+=nums[right];

判断条件就为:(tmp>target)

出窗口:tmp-=nums[left++];

更新条件就为:if(tmp==target)  ret=max(ret,right-left+1);

 

 

e41cb95ed39146debcf965c316383faa.png

 

 对图中的每一步完善:

591ac90809234febaf8f1456a174e0f0.png

代码实现:

class Solution {
public:int minOperations(vector<int>& nums, int x) {int sum=0;for(auto& num:nums) sum+=num;if(sum<x) return -1;int target=sum-x;int left=0,right=0;int n=nums.size();int tmp=0;int ret=-1;for(;right<n;right++){tmp+=nums[right];while(tmp>target){tmp-=nums[left++];}if(tmp==target){ret=max(ret,right-left+1);}}return ret==-1?-1:n-ret;}
};

第五题:904. 水果成篮 - 力扣(LeetCode)

f5210b50c24642118b154de4a84fd3f7.png

题目解释:

 这一道题读下来就很蒙了,根本不知道在说什么。

如果用一句话概括就是:找至多包含两种元素的最长子串(连续),返回其长度。

如果英文直译就是:您正在参观一个农场,该农场有一排从左到右排列的果树。树由整数数组fruits表示,其中水果[i]是第i棵树产生的水果类型。 你想收集尽可能多的水果。但是,所有者有一些严格的规则,您必须遵守: 你只有两个篮子,每个篮子只能装一种水果。每篮水果的数量没有限制。 从您选择的任何一棵树开始,您必须在向右移动时从每棵树(包括起始树)中恰好摘下一个水果,摘下的水果必须放在你的一个篮子里。 一旦你到了一棵树上,树上的果实没法放入你的篮子(两个篮子已经满了),你必须停下来。 给定整数数组水果,返回可以拾取的最大水果数。 本题,其实就是选只有两个元素的最长连续子序列,比如1,2,3,2,2最长就是2,3,2,2(只包括2或者3,而且是最长的)。

算法原理:

那么这道题就很好解决了,用滑动窗口来写,难度甚至可以说是简单题,但是我们需要解决的一点就是如何判断添加下一个元素后,使得包含的元素种类超过2.

对于这个问题,第一时间想到的应该时引用哈希表。

这里就不在按照滑动窗口的三小步来写了,直接给出用哈希与滑动窗口的代码了

class Solution {
public:int totalFruit(vector<int>& fruits) {int ret=0;int n=fruits.size();unordered_map<int,int> mp;for(int left=0,right=0,count=0;right<n;right++){//进窗口mp[fruits[right]]++;count++;//判断 出窗口while(mp.size()>2){mp[fruits[left]]--;if(mp[fruits[left]]==0){mp.erase(fruits[left]);}left++;count--;}ret=max(ret,count);}return ret;}
};

但是这样提交代码后

78187c7e9fee44169c8c0dbe2d7ed031.png

所以我们来说一下优化

我们知道哈希表的删除的时间复杂度时0(n)的,所以对于时间的优化就是对与哈希表的优化,能否不用删除呢? 如果说不用删除的话,那么对于判断条件就不能用mp.size()>2了,就需要用迭代器遍历,统计哈希表的长度了,我们修改一下,看看时间消耗

代码:

class Solution {
public:int totalFruit(std::vector<int>& fruits) {int ret = 0;int n = fruits.size();std::unordered_map<int, int> mp;  // 存储水果种类及其数量int left = 0;  // 滑动窗口的左边界for (int right = 0; right < n; ++right) {// 进窗口,增加当前右指针所指水果的数量mp[fruits[right]]++;// 判断是否超过两种水果,如果超过,则开始收缩窗口while (countUniqueFruits(mp) > 2) {// 移动左指针,减少左指向水果的数量mp[fruits[left]]--;left++;  // 收缩窗口}// 更新最大窗口大小ret = std::max(ret, right - left + 1);}return ret;}private:// 辅助函数:计算当前窗口内不同水果的种类数int countUniqueFruits(const std::unordered_map<int, int>& mp) {int uniqueCount = 0;for (const auto& entry : mp) {if (entry.second > 0) {uniqueCount++;}}return uniqueCount;}
};

但是运行提交发现:

34807d3258bd47d9b0e6910280b16b29.png

所以说我们还是要另辟蹊径,要舍去用哈希表,我们不妨使用vector来维护

 

class Solution {
public:int totalFruit(vector<int>& fruits) {int left = 0;vector<int> intCounts(fruits.size());//记录某种水果采摘的个数int kinds = 0;//记录采摘水果的种类int ans = 0;for(int i=0;i<fruits.size();i++){if(intCounts[fruits[i]] == 0){kinds++;}intCounts[fruits[i]]++;while(kinds >2){//发现采摘种类大于2时,left开始右移intCounts[fruits[left]]--;//每次右移都丢掉对应篮子里的水果if(intCounts[fruits[left]] == 0){ // 直到把某个篮子里的水果丢空则种类-1.kinds--;}left++;}ans = max(ans,i-left+1);}return ans;}
};

这样就好多了

eda3ea32315248e6b65973a9d58f170d.png

第六题:30. 串联所有单词的子串 - 力扣(LeetCode) 

c5e8a3797866480f8ac666215a92527f.png

对于这道题不要看到是困难就怕了,看到题目这么长就不想看了,其实用滑动窗口来写,其实不是那么的难。只需要把细节处理好久简单多了。 

只是相对于上面的等题是对单个字符进行操作,这里的操作变为了对一个小的字符串进行操作

其实本质还是一样的。

那么这里就给出不一样的区别,right指针像前面都是移动长度为1,这里变为了len(len为words里面每个字符串的长度),哈希表的键值对存的是<string,int>,而不是像前面几个题一样存的是<int,int>或者<char,int>。

  • 基本变量设置

    • len:每个单词的长度。
    • n:字符串 s 的长度。
    • m:单词数组 words 中单词的数量。
    • hash1:记录 words 中每个单词的出现次数,作为参考标准。
  • 外层循环

    • i 代表当前尝试的起始位置,外层循环的目的是为了从字符串 s 中不同的起始位置开始尝试。因为每个单词的长度是固定的,因此从 0len-1 的不同起始位置可以保证覆盖所有可能的排列。

这种写法仅实现了单层循环,确保了从首个字符开始逐个遍历检查该单词是否存在于words中。这意味着,尽管第1、2、3个字符的组合恰好存在于words中,但第0、1、2个字符的组合却并不存在。所以我们还需要设置外层循环,循环len次

47347670fdc043c0a0e52c3d20bb3510.png

  • 滑动窗口

    • 内层循环使用 leftright 来标记滑动窗口的左右边界。
    • right 每次增加 len,即窗口向右扩展一个单词的长度。
    • left 是窗口的左边界,只有当窗口的总长度大于 len * m 时,left 才会向右移动(收缩窗口)。
  • 哈希表

    • hash2:记录当前窗口内每个单词出现的次数。
    • right 指针扩展时,hash2 增加当前单词的计数。如果该单词出现的次数小于等于 words 中该单词的频次 (hash1),count 就会增加。
  • 窗口收缩

    • 当窗口大小超过 len * m(即包含了超过 m 个单词的长度),需要收缩窗口。通过移动 left 来收缩窗口,直到窗口中只包含 m 个单词。
    • 收缩时,left 向右移动,移出窗口的单词会从 hash2 中减去计数,如果该单词的计数为 0,则直接从 hash2 中删除该单词。
  • 判断合法窗口

    • 如果窗口内的单词数量等于 m(即当前窗口包含了 words 中的所有单词),就记录下 left 作为有效的子串起始位置。

那么根据思路写出代码

class Solution {
public:vector<int> findSubstring(string s, vector<string>& words) {vector<int> v;int len = words[0].size();int n = s.size();int m = words.size();unordered_map<string, int> hash1;for (auto& word : words) hash1[word]++;for (int i = 0; i < len; i++){unordered_map<string, int> hash2;for (int left = i, right = i, count = 0; right < n; right += len){// 进窗口string in = s.substr(right, len);hash2[in]++;if (hash2[in] <= hash1[in]) count++;//判断出if (right - left + 1 > len * m){string out = s.substr(left, len);if (hash2[out] <= hash1[out]) count--;hash2[out]--;if (hash2[out] == 0){hash2.erase(out);}left += len;}if (count == m){v.push_back(left);}}}return v;}
};

提交发现,效果不是很佳,所以我们就要进行必要的优化,对于哈希表的删除是一个0(n)的时间复杂度,所以我们要尽可能避免进行删除, 

435a9e30cdcf48ff817080a71dc3c248.png

我看了看别人的思路,然后结合了一下,对代码进行了修改

修改地方如下:

如果要进窗口的字符串在words内不存在,那么就进行伪插入到hash2,这样,如果在出窗口是,如果要出窗口的字符串本就不在words内,那就根本就不需要进行删除或者hash2的second--,如果在,那么只进行--,如果--到0,也没关系,因为我们还定义了另一个变量计数器count统计其符合的字符串数量。

class Solution {
public:vector<int> findSubstring(string s, vector<string>& words) {vector<int> v;int len = words[0].size();int n = s.size();int m = words.size();if (n < len * m) return v; // 长度不够的情况unordered_map<string, int> hash1; // 记录每个单词出现的次数for (const auto& word : words) hash1[word]++;// 外层循环:从 0 到 len-1,每次从不同位置开始for (int i = 0; i < len; i++) {unordered_map<string, int> hash2; // 记录当前窗口中单词出现的次数int left = i, right = i, count = 0;while (right + len <= n) {// 进窗口string in = s.substr(right, len);right += len;if (hash1.find(in) != hash1.end()) {hash2[in]++;if (hash2[in] <= hash1[in]) {count++;}}// 判断出窗口,收缩窗口while (right - left > len * m) {string out = s.substr(left, len);left += len;if (hash1.find(out) != hash1.end()) {if (hash2[out] <= hash1[out]) {count--;}hash2[out]--; // 直接减少,不调用 erase}}// 如果窗口内包含了所有单词if (count == m) {v.push_back(left);}}}return v;}
};

这样,无论时间上还是空间上,都得到了很大的优化

0831a9ae074d4e099078287f4546d0b5.png

第七题: 438. 找到字符串中所有字母异位词 - 力扣(LeetCode)

73f21ad3df3c444493c85fa30810d582.png

需要解释的就是何为字母异位词7a459b531e9048e58a69b2cc101f82cb.png 

比如示例一的cba,bac都是abc异位词。

  1. 初始化字符频率

    • hash1 数组用于存储字符串 p 中每个字母的频率(大小为26,因为只有小写字母)。
    • hash2 数组用于存储当前滑动窗口内的字符频率。
  2. 滑动窗口

    • 使用两个指针 left 和 right 来表示滑动窗口的范围,right 用于扩展窗口,left 用于收缩窗口。
    • count 变量用于记录当前窗口中已匹配的字符数。
  3. 窗口扩展

    • 每次移动 right 指针时,增加 right 指向字符的频率计数 (hash2)。
    • 如果当前字符在 s 中的计数不超过在 p 中的计数,count 变量增加,表示当前字符已经符合要求。
  4. 窗口收缩

    • 如果窗口的大小超过了 p 的长度 m(即 right - left + 1 > m),则需要通过移动 left 指针来缩小窗口,并更新 hash2 中相应字符的计数。
    • 如果移除的字符的计数仍然不超过 p 中相应字符的计数,则 count 减少。
  5. 匹配检测

    • 每当 count 等于 m 时,说明当前窗口中的字符频率与 p 完全匹配,此时记录当前窗口的左边界 left 作为一个有效的起始索引。
  6. 返回结果

    • 最终,所有符合条件的起始位置会被存入 ret 向量,并返回。
class Solution {
public:vector<int> findAnagrams(string s, string p) {int hash1[26]={0};int m=p.size();for(auto& e:p) hash1[e-'a']++;int hash2[26]={0};int n=s.size();vector<int> ret;for(int left=0,right=0,count=0;right<n;right++){char in=s[right];//进窗口hash2[in-'a']++;if(hash2[in-'a']<=hash1[in-'a']) count++;//出窗口char ou=s[left];if(right-left+1>m ){if(hash2[ou-'a']--<=hash1[ou-'a']) count--;left++;}//更新结果if(count==m){ret.push_back(left);}}return ret;}
};

 第八题:76. 最小覆盖子串 - 力扣(LeetCode)

04c0d5b36fb54a8bba4105a2e123f58b.png

题目解释:

对于本道题,读一遍便可以知道要做什么,那我要提醒的是:对于示例一,用黑色框起来的也算其结果之一,只是不是最优解,虽然他又两个B,但也是一种结果。

0771d71a63bc46b0afd70299715e3312.png

对于本道题其实根本谈不上困难

用滑动窗口来写,大致思路就是下面的图形思路,但是这里就不提倡用哈希表了,建议使用创建一个大小128的数组来维护。后面说为什么。

8f1da31534bc4cb59180e9d9200ede94.png 

但是这样写完,换句话说在代码中的check就发现其实check其实非常耗时间的,因为我们要遍历哈希表,如果正好符合要求还好,如果迭代器遍历的时候是需要两个迭代器的,你要做到的就是要保证两个迭代器对应的first一致。这就很难保证。

所以就像上面说的建议用数组,然而用数组的话又要遍历128遍,虽然对于cpu128遍很快,但我们还是要进行优化的。

优化方式就是使用一个count计数器,统计符合要求的个数。

代码如下:

class Solution {
public:string minWindow(string s, string t) {int n=s.size();int hash1[128]={0};int kinds=0;for(auto& e:t){if(hash1[e]==0){kinds++;}hash1[e]++;}int mi=INT_MAX;int hash2[128]={0};int begin=-1;for(int left=0,right=0,count=0;right<n;right++){char in=s[right];if(++hash2[in]==hash1[in]) count++;while(count==kinds){if(right-left+1<mi){mi=right-left+1;begin=left;}char ou=s[left];if(hash2[ou]==hash1[ou]) count--;hash2[ou]--;left++;}}if(begin==-1) return "";else return s.substr(begin,mi);}
};

总结:

滑动窗口(Sliding Window)是一种在数组或字符串等线性数据结构上进行子数组(或子字符串)操作的技术,常用于处理具有 连续性 或 局部性质 的问题。总结来说,滑动窗口适用于以下几种情境:

1. 子数组/子串的所有情况需要遍历

  • 当问题要求你遍历某个子数组或子串的所有可能的连续部分时,滑动窗口是一种非常高效的解法。通过动态调整窗口的大小或位置,你可以避免重复计算,从而提高效率。

2. 需要计算某些连续元素的属性(如和、最大值、最小值、频率等)

  • 典型的滑动窗口问题包括计算连续子数组的和、最大最小值、平均值、字符出现的频率等。
  • 例子:给定一个整数数组 nums,你需要计算所有大小为 k 的子数组的和。使用滑动窗口可以避免重新计算每个子数组的和,从而降低时间复杂度。

3. 找到满足某些条件的最短或最长子数组

  • 当需要找到满足某些条件(如和、乘积、满足某种限制)的最短或最长的子数组时,滑动窗口特别有用。通过动态调整窗口的左右边界,可以逐渐扩大或收缩窗口,以满足问题的需求。
  • 例子:给定一个字符串,你需要找到包含所有字母异位词的最短子串。

4. 当问题可以通过增量或递减计算的方式优化

  • 滑动窗口的一个关键优势是当窗口扩展或收缩时,能够增量式地更新结果,避免重新计算整个子数组或子串的结果。
  • 例子:在求解字符串中的某些字符的频率或和时,滑动窗口允许你快速更新窗口边界,而不需要每次都重新计算全部内容。

5. 有固定大小的窗口或可变大小的窗口

  • 滑动窗口有两种常见变体:
    • 固定大小的窗口:例如,在一个数组中找到长度为 k 的所有子数组或子串。
    • 可变大小的窗口:窗口大小根据某些条件动态变化,常用于寻找最小或最大符合条件的子数组。例如,找到和大于等于某个目标值的最小子数组。

适用的典型问题:

  • 固定大小窗口

    • 子数组最大和问题:给定一个整数数组 nums 和一个整数 k,求所有大小为 k 的子数组的最大和。
    • 长度为 k 的滑动窗口内的元素和。
  • 可变大小窗口

    • 最小覆盖子串:给定一个字符串 s 和一个模式 p,找出 s 中包含 p 所有字符的最小子串。
    • 最长子数组和:给定一个数组,找到子数组和小于等于某个目标值的最长子数组。
    • 找出字符串中所有包含某些字符的最短子串。

何时不使用滑动窗口:

  • 不连续的子数组:如果问题需要处理的是非连续的子数组或子串(如跳跃式的选择),滑动窗口不适用。
  • 需要处理复杂的动态结构:如果问题中涉及到大量的随机访问或复杂的元素操作,滑动窗口可能无法提供明显的效率提升。

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/470665.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

车载空气净化器语音芯片方案

开发背景&#xff1a; 随着人们生活质量的不断提升和环保意识的日益增强&#xff0c;车内空气质量成为了广大车主关注的焦点。长时间封闭的车厢环境&#xff0c;加之城市空气污染、新车内饰材料释放的有害气体等因素&#xff0c;使得车内空气质量往往不尽如人意&#xff0c;严重…

《MYSQL45讲》误删数据怎么办

对误删数据分类的话&#xff0c;有 1.delete 误删行 2.drop table 或者truncate table 语句误删表 3.使用drop database 误删数据库 4.使用rm命令误删整个MYSQL实例 一&#xff0c;误删行 一下操作前置条件是&#xff1a;binlog的格式是row&#xff0c;并且binglog_row_im…

不对称信息

你买了一辆二手车&#xff0c;你并不知道它出过几次事故&#xff0c;但它之前的车主却对此了如指掌。来买保险的公司都是那些出险概率很大的&#xff08;比如矿工、化工厂&#xff09;&#xff0c;但那些安全的公司很少去买保险&#xff0c;这两种问题都属于信息不对称问题。 …

94个属于一区且接受医工交叉领域投稿的期刊汇总|个人观点·24-11-13

小罗碎碎念 继汇总病理AI的基础模型、病理组学&影像组学的公开数据集以后&#xff0c;我们再来盘一盘医工交叉领域有哪些热门期刊可以投稿。我会分区进行介绍&#xff0c;每个区则会进一步划分学科种类&#xff0c;方便大家选择适合自己的投稿期刊。 这期推文先分享大类属…

网站小程序app怎么查有没有备案?

网站小程序app怎么查有没有备案&#xff1f;只需要官方一个网址就可以&#xff0c;工信部备案查询官网地址有且只有一个&#xff0c;百度搜索 "ICP备案查询" 找到官方gov.cn网站即可查询&#xff01; 注&#xff1a;网站小程序app备案查询&#xff0c;可通过输入单位…

MySQL45讲 第二十讲 幻读是什么,幻读有什么问题?

文章目录 MySQL45讲 第二十讲 幻读是什么&#xff0c;幻读有什么问题&#xff1f;一、幻读的定义二、幻读带来的问题&#xff08;一&#xff09;语义问题&#xff08;二&#xff09;数据一致性问题 三、InnoDB 解决幻读的方法四、总结 MySQL45讲 第二十讲 幻读是什么&#xff0…

FatLab:我的编程课程系列

FatLab 是一款教程类软件。 大概是因为我的编程生涯始于自学&#xff0c;FatLab便也保持了这种气息&#xff1a;从一个“自然生长”的角度提供了一套C语言教程。 教程方面&#xff0c;目前仅完成了《C语言基础要素》系列。正如其名&#xff0c;这个系列仅探讨了语言中非常基础…

冗余连接2 hard题 代随C#写法

此题在卡码网109与力扣685题亦有记载 有一说一C#写法我没咋搞懂 就看明白了思路 这里贴一个答案待后续我醒悟了再来看罢 难就难在对整体数据结构classUnion&#xff08;并查集&#xff09;的理解不熟并且 对于输入输出这个迭代过程理解上也比较吃力 109. 冗余连接II 题…

【QT】QSS

个人主页~ 一、QSS QSS可以说是拿了CSS的一部分过来用&#xff0c;是CSS的简化版本 1、基本语法 选择器 {属性名:属性值; }将界面上所有的QPushButton文本颜色都改为红色 QPushButton {color:red; }2、设置方式 &#xff08;1&#xff09;指定控件样式设置 在widget.cpp中…

java模拟键盘实现selenium上下左右键 table中的左右滚动条实现滚动

在这篇文章中&#xff0c;我们将学习如何使用Java编程语言模拟键盘输入&#xff0c;特别是模拟上下左右方向键的操作。这是一个很有趣的项目&#xff0c;尤其适合刚入行的开发者。我们将分步进行&#xff0c;接下来&#xff0c;我们会通过表格展示整个实现过程&#xff0c;然后…

JQuery封装的ajax

1. 注意&#xff1a; 首先要导jq的包json对象可以用 . 来调用keyjava只能给前端传页面&#xff0c;或者打印的内容String jsonstr json.toJSONString(resultJSON); //将对象转为JSON对象 Json格式和参数解释&#xff1a; <script src"js/jquery-1.10.2.min.js&quo…

文献解读-DNAscope: High accuracy small variant calling using machine learning

关键词&#xff1a;基准与方法研究&#xff1b;基因测序&#xff1b;变异检测&#xff1b; 文献简介 标题&#xff08;英文&#xff09;&#xff1a;DNAscope: High accuracy small variant calling using machine learning标题&#xff08;中文&#xff09;&#xff1a;DNAsc…

vue中如何关闭eslint检测?

ESLint作为一个用于JavaScript代码的验证工具&#xff0c;主要用于检查代码语法和编码规范。本文旨在指导那些希望在Vue.js项目中禁用ESLint验证功能的用户。对于需要这一操作的朋友&#xff0c;以下内容将提供参考。 vue中如何关闭eslint检测&#xff1f; 有了eslint的校验&…

用vscode编写verilog时,如何有信号定义提示、信号定义跳转(go to definition)、模块跳转这些功能

&#xff08;一&#xff09;安装插件SystemVerilog - Language Support 安装一个vscode插件即可&#xff0c;插件叫SystemVerilog - Language Support。虽然说另一个插件“Verilog-HDL/SystemVerilog/Bluespec SystemVerilog”也有信号提示及定义跳转功能&#xff0c;但它只能提…

️️一篇快速上手 AJAX 异步前后端交互

AJAX 1. AJAX1.1 AJAX 简介1.2 AJAX 优缺点1.3 AJAX 前后端准备1.4 AJAX 请求基本操作1.5 AJAX 发送 POST 请求1.6 设置请求头1.7 响应 JSON 数据1.8 AJAX 请求超时与网络异常处理1.9 取消请求1.10 Fetch 发送 Ajax 请求 2. jQuery-Ajax2.1 jQuery 发送 Ajax 请求&#xff08;G…

❤React-React 组件通讯

❤ React 组件通讯 组件通讯将教我们的内容&#xff1a; 能够使用道具接收数据W能够实现父子组件之间的通讯能够实现兄弟组件之间的通讯能够给组件添加道具校验能够说出生命周期常用的钩子函数能够知道高阶组件的作用 1、 组件通讯介绍 组件是独立且封闭的单元&#xff0c;…

【初阶数据结构与算法】链表刷题之移除链表元素、反转链表、找中间节点、合并有序链表、链表的回文结构

文章目录 一、移除链表元素思路一思路二 二、合并两个有序链表思路&#xff1a;优化&#xff1a; 三、反转链表思路一思路二 四、链表的中间节点思路一思路二 五、综合应用之链表的回文结构思路一&#xff1a;思路二&#xff1a; 一、移除链表元素 题目链接&#xff1a;https:…

POI实现根据PPTX模板渲染PPT

目录 1、前言 2、了解pptx文件结构 3、POI组件 3.1、引入依赖 3.2、常见的类 3.3、实现原理 3.4、关键代码片段 3.4.1、获取ppt实例 3.4.2、获取每页幻灯片 3.4.3、循环遍历幻灯片处理 3.4.3.1、文本 3.4.3.2、饼图 3.4.3.3、柱状图 3.4.3.4、表格 3.4.3.5、本地…

计算机毕业设计Python+Neo4j知识图谱医疗问答系统 大模型 机器学习 深度学习 人工智能 大数据毕业设计 Python爬虫 Python毕业设计

温馨提示&#xff1a;文末有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 温馨提示&#xff1a;文末有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 温馨提示&#xff1a;文末有 CSDN 平台官方提供的学长联系方式的名片&#xff01; 作者简介&#xff1a;Java领…

【机器学习】机器学习中用到的高等数学知识-2.概率论与统计 (Probability and Statistics)

概率分布&#xff1a;理解数据的分布特征&#xff08;如正态分布、伯努利分布、均匀分布等&#xff09;。期望和方差&#xff1a;描述随机变量的中心位置和离散程度。贝叶斯定理&#xff1a;用于推断和分类中的后验概率计算。假设检验&#xff1a;评估模型的性能和数据显著性。…