【算法专题】滑动窗口

【算法专题】滑动窗口

滑动窗口

1. 长度最小的子数组

题目链接 -> Leetcode -209.长度最小的子数组

Leetcode -209.长度最小的子数组

题目:给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组[numsl, numsl + 1, …, numsr - 1, numsr] ,并返回其长度。
如果不存在符合条件的子数组,返回 0 。

示例 1:
输入:target = 7, nums = [2, 3, 1, 2, 4, 3]
输出:2
解释:子数组[4, 3] 是该条件下的长度最小的子数组。

示例 2:
输入:target = 4, nums = [1, 4, 4]
输出:1

示例 3:
输入:target = 11, nums = [1, 1, 1, 1, 1, 1, 1, 1]
输出:0

提示:
1 <= target <= 10^9
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

思路:由于此问题分析的对象是「⼀段连续的区间」,因此可以考虑「滑动窗口」的思想来解决这道题。让滑动窗口满足:从 i 位置开始,窗口内所有元素的和小于 target (那么当窗口内元素之和第一次大于等于目标值的时候,就是 i 位置开始,满足条件的最小长度)。
做法:将右端元素划入窗口中,统计出此时窗口内元素的和:
▪ 如果窗口内元素之和大于等于 target :更新结果,并且将左端元素划出去的同时继续判断是否满足条件并更新结果(因为左端元素可能很小,划出去之后依旧满足条件)
▪ 如果窗口内元素之和不满足条件: right++ ,另下⼀个元素进⼊窗口。

代码如下:

		class Solution {
		public:
		    int minSubArrayLen(int target, vector<int>& nums) 
		    {
		        int left = 0,right = 0,sum = 0,ans = INT_MAX;
		        while(right < nums.size())
		        {
		            // 进窗口
		            sum += nums[right];
		
		            // 满足条件就更新结果
		            while(sum >= target)
		            {
		                ans = min(ans, right - left + 1);
		
		                // 出窗口
		                sum -= nums[left];
		                left++;
		            }
		            right++;
		        }
		        return ans == INT_MAX? 0 : ans;
		    }
		};

为何滑动窗口可以解决问题,并且时间复杂度更低?

  • 这个窗口寻找的是:以当前窗口最左侧元素(记为 left1 )为基准,符合条件的情况。也就是在这道题中,从 left1 开始,满足区间和 sum >= target 时的最右侧(记为right1 )能到哪里。
  • 我们既然已经找到从 left1 开始的最优的区间,那么就可以大胆舍去 left1 。但是如果继续像暴力解法,重新开始统计第二个元素( left2 )往后的和,势必会有大量重复的计算(因为我们在求第一段区间的时候,已经算出很多元素的和了,这些和是可以在计算下次区间和的时候用上的)。
  • 此时, rigth1 的作用就体现出来了,我们只需将 left1 这个值从 sum 中剔除。从 right1 这个元素开始,往后找满足 left2 元素的区间(此时 right1 也有可能是满足的,因为 left1 可能很小。 sum 剔除掉 left1 之后,依旧满足大于等于 target )。这样我们就能省掉大量重复的计算。这样我们不仅能解决问题,而且效率也会大大提升。
  • 时间复杂度:虽然代码是两层循环,但是我们的 left 指针和 right 指针都是不回退的,两者最多都往后移动 n 次。因此时间复杂度是 O(N).

2. 无重复字符的最长子串

题目链接 -> Leetcode -3.无重复字符的最长子串

Leetcode -3.无重复字符的最长子串

题目:给定一个字符串 s ,请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:
输入: s = “abcabcbb”
输出 : 3
解释 : 因为无重复字符的最长子串是 “abc”,所以其长度为 3。

示例 2 :
输入 : s = “bbbbb”
输出 : 1
解释 : 因为无重复字符的最长子串是 “b”,所以其长度为 1。

示例 3 :
输入 : s = “pwwkew”
输出 : 3
解释 : 因为无重复字符的最长子串是 “wke”,所以其长度为 3。
请注意,你的答案必须是 子串 的长度,“pwke” 是一个子序列,不是子串。

提示:
0 <= s.length <= 5 * 10^4
s 由英文字母、数字、符号和空格组成

思路:研究的对象依旧是一段连续的区间,因此继续使用「滑动窗口」思想来优化。让滑动窗口满足:窗口内所有元素都是不重复的。
做法:右端元素 ch 进⼊窗口的时候,哈希表统计这个字符的频次:
a. 如果这个字符出现的频次超过 1 ,说明窗口内有重复元素,那么就从左侧开始划出窗口,直到 ch 这个元素的频次变为 1 ,然后再更新结果。
b. 如果没有超过 1 ,说明当前窗口没有重复元素,可以直接更新结果

代码如下:

		class Solution {
		public:
		    int lengthOfLongestSubstring(string s)
		    {
		        if (s.size() == 0) return 0;
		
		        int hash[128] = { 0 };
		
		        int ans = INT_MIN;
		        for (int left = 0, right = 0; right < s.size(); right++)
		        {
		            // 进窗口
		            hash[s[right]]++;
		
		            // 出窗口
		            while (hash[s[right]] > 1)
		            {
		                hash[s[left]]--;
		                left++;
		            }
		
		            // 出窗口后取值
		            ans = max(right - left + 1, ans);
		        }
		        return ans;
		    }
		};

3. 最大连续1的个数Ⅲ

题目链接 -> Leetcode -1004.最大连续1的个数Ⅲ

Leetcode -1004.最大连续1的个数Ⅲ

题目:给定一个二进制数组 nums 和一个整数 k,如果可以翻转最多 k 个 0 ,则返回 数组中连续 1 的最大个数 。

示例 1:
输入:nums = [1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0], K = 2
输出:6
解释:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1]
粗体数字从 0 翻转到 1,最长的子数组长度为 6。

示例 2:
输入:nums = [0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1], K = 3
输出:10
解释:[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1]
粗体数字从 0 翻转到 1,最长的子数组长度为 10。

提示:
1 <= nums.length <= 10^5
nums[i] 不是 0 就是 1
0 <= k <= nums.length

思路:不用去想怎么翻转,这道题的结果无非就是⼀段连续的 1 中间塞了 k 个 0 ;因此,我们可以把问题转化成:求数组中一段最长的连续区间,要求这段区间内 0 的个数不超过 k 个。

代码如下:

		class Solution {
		public:
		    int longestOnes(vector<int>& nums, int k) 
		    {
		        int ans = 0, tmp = k;
		        for(int left = 0,right = 0;right < nums.size();right++)
		        {
		            // 有一个 0 进窗口 k 就减一
		            if(nums[right] == 0 && k >= 0)
		            {
		                k--;
		            }
		            
		            // 窗口内超过 k 个 0,出窗口并更新 k
		            while(nums[right] == 0 && k < 0)
		            {
		                if(nums[left] == 0)
		                    ++k;
		
		                left++;
		            }
		            ans = max(ans, right - left + 1);
		        }
		        return ans;
		    }
		};

4. 将 x 减到 0 的最小操作数

题目链接 -> Leetcode -1658.将 x 减到 0 的最小操作数

Leetcode -1658.将 x 减到 0 的最小操作数

题目:给你一个整数数组 nums 和一个整数 x 。每一次操作时,你应当移除数组 nums 最左边或最右边的元素,然后从 x 中减去该元素的值。
请注意,需要 修改 数组以供接下来的操作使用。

如果可以将 x 恰好 减到 0 ,返回 最小操作数 ;否则,返回 - 1 。

示例 1:
输入:nums = [1, 1, 4, 2, 3], x = 5
输出:2
解释:最佳解决方案是移除后两个元素,将 x 减到 0 。

示例 2:
输入:nums = [5, 6, 7, 8, 9], x = 4
输出: - 1

示例 3:
输入:nums = [3, 2, 20, 1, 1, 3], x = 10
输出:5
解释:最佳解决方案是移除后三个元素和前两个元素(总共 5 次操作),将 x 减到 0 。

提示:
1 <= nums.length <= 10^5
1 <= nums[i] <= 10^4
1 <= x <= 10^9

思路:我们可以转化成求数组内一段连续的、和为 sum(nums) - x 的最长数组。此时,就是熟悉的「滑动窗口」问题了。

代码如下:

		class Solution {
		public:
		    int minOperations(vector<int>& nums, int x)
		    {
		        int ans = INT_MIN, sum = 0;
		
		        // 转换为求和为 sum(nums)-x 的最长子数组问题
		        for (int i = 0; i < nums.size(); i++) sum += nums[i];
		
		        int target = sum - x, slipSum = 0;
		        if (target < 0) return -1;
		
		        // 操作窗口
		        for (int left = 0, right = 0; right < nums.size(); right++)
		        {
		            // 进窗口
		            slipSum += nums[right];
		
		            // 出窗口
		            while (slipSum > target)
		            {
		                slipSum -= nums[left];
		                left++;
		            }
		
		            // 更新数据
		            if (slipSum == target)
		                ans = max(ans, right - left + 1);
		        }
		
		        return ans == INT_MIN ? -1 : nums.size() - ans;
		    }
		};

5. 水果成篮

题目链接 -> Leetcode -904.水果成篮

Leetcode -904.水果成篮

题目:你正在探访一家农场,农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示,其中 fruits[i] 是第 i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而,农场的主人设定了一些严格的规矩,你必须按照要求采摘水果:

  • 你只有两个篮子,并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
  • 你可以选择任意一棵树开始采摘,你必须从 每棵 树(包括开始采摘的树)上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次,你将会向右移动到下一棵树,并继续采摘。
  • 一旦你走到某棵树前,但水果不符合篮子的水果类型,那么就必须停止采摘。

给你一个整数数组 fruits ,返回你可以收集的水果的 最大 数目。

示例 1:
输入:fruits = [1, 2, 1]
输出:3
解释:可以采摘全部 3 棵树。

示例 2:
输入:fruits = [0, 1, 2, 2]
输出:3
解释:可以采摘[1, 2, 2] 这三棵树。
如果从第一棵树开始采摘,则只能采摘[0, 1] 这两棵树。

示例 3:
输入:fruits = [1, 2, 3, 2, 2]
输出:4
解释:可以采摘[2, 3, 2, 2] 这四棵树。
如果从第一棵树开始采摘,则只能采摘[1, 2] 这两棵树。

示例 4:
输入:fruits = [3, 3, 3, 1, 2, 1, 1, 2, 3, 3, 4]
输出:5
解释:可以采摘[1, 2, 1, 1, 2] 这五棵树。

提示:
1 <= fruits.length <= 10^5
0 <= fruits[i] < fruits.length

思路:研究的对象是一段连续的区间,可以使用「滑动窗口」思想来解决问题。让滑动窗口满足:窗口内水果的种类只有两种。
做法:右端水果进入窗口的时候,用哈希表统计这个水果的频次。这个水果进来后,判断哈希表的大小:

  • 如果大小超过 2:说明窗口内水果种类超过了两种。那么就从左侧开始依次将水果划出窗口,直到哈希表的大小小于等于 2,然后更新结果;
  • 如果没有超过 2,说明当前窗口内水果的种类不超过两种,直接更新结果 ans.

代码如下:

		class Solution {
		public:
		    int totalFruit(vector<int>& fruits) 
		    {
		        int ans = 0;
		        unordered_map<int, int> hash;
		
		        for(int left = 0,right = 0;right < fruits.size();right++)
		        {
		            // 进窗口
		            hash[fruits[right]]++;
		
		            // 超过两个种类的水果,就出窗口,并更新哈希表
		            while(hash.size() > 2)
		            {
		                hash[fruits[left]]--;
		
		                // 如果当前水果种类已经为 0,删除哈希表中这种水果的种类
		                if(hash[fruits[left]] == 0)
		                    hash.erase(fruits[left]);
		
		                left++;
		            }
		
		            ans = max(ans, right - left + 1);
		        }
		
		        return ans;
		    }
		};

6. 找到字符串中所有字母异位词

题目链接 -> Leetcode -438.找到字符串中所有字母异位词

Leetcode -438.找到字符串中所有字母异位词

题目:给定两个字符串 s 和 p,找到 s 中所有 p 的 异位词 的子串,返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串(包括相同的字符串)。

示例 1:
输入: s = “cbaebabacd”, p = “abc”
输出 : [0, 6]
解释 :
起始索引等于 0 的子串是 “cba”, 它是 “abc” 的异位词。
起始索引等于 6 的子串是 “bac”, 它是 “abc” 的异位词。

示例 2 :
输入 : s = “abab”, p = “ab”
输出 : [0, 1, 2]
解释 :
起始索引等于 0 的子串是 “ab”, 它是 “ab” 的异位词。
起始索引等于 1 的子串是 “ba”, 它是 “ab” 的异位词。
起始索引等于 2 的子串是 “ab”, 它是 “ab” 的异位词。

提示 :
1 <= s.length, p.length <= 3 * 10^4
s 和 p 仅包含小写字母

思路:

  • 因为字符串 p 的异位词的长度一定与字符串 p 的长度相同,所以我们可以在字符串 s 中构造一个长度为与字符串 p 的长度相同的滑动窗口,并在滑动中维护窗口中每种字母的数量;
  • 当窗口中每种字母的数量与字符串 p 中每种字母的数量相同时,则说明当前窗口为字符串 p的异位词;
  • 因此可以用两个大小为 26 的数组来模拟哈希表,一个来保存 s 中的子串每个字符出现的个数,另一个来保存 p 中每⼀个字符出现的个数。这样就能判断两个串是否是异位词。

代码如下:

		class Solution {
		public:
		    vector<int> findAnagrams(string s, string p) 
		    {
		        vector<int> ret;
		        int hash1[26] = {0};
		        for(auto& ch : p) hash1[ch - 'a']++;
		        int len = p.size();
		
		        int hash2[26] = {0};
		
		        // count 维护s在p中的有效字符个数
		        int count = 0;
		        for(int left = 0,right = 0;right < s.size();right++)
		        {
		            hash2[s[right] - 'a']++;
		            if(hash2[s[right] - 'a'] <= hash1[s[right] - 'a']) count++;
		
		            // 出窗口
		            if(right - left + 1 > len)
		            {
		                char out = s[left];
		                left++;
		
		                // 判断出窗口的字符是否是p中的有效字符,如果是则维护 count
		                if(hash2[out - 'a'] <= hash1[out - 'a']) count--;
		                hash2[out - 'a']--;
		            }
		            
		            if(count == len)
		            {
		                ret.push_back(left);
		            }
		        }
		        return ret;
		    }
		};

7. 串联所有单词的子串

题目链接 -> Leetcode -30.串联所有单词的子串

Leetcode -30.串联所有单词的子串

题目:给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。

s 中的 串联子串 是指一个包含 words 中所有字符串以任意顺序排列连接起来的子串。

例如,如果 words = [“ab”, “cd”, “ef”], 那么 “abcdef”, “abefcd”,“cdabef”, “cdefab”,“efabcd”, 和 “efcdab” 都是串联子串。 “acdbef” 不是串联子串,因为他不是任何 words 排列的连接。
返回所有串联子串在 s 中的开始索引。你可以以 任意顺序 返回答案。

示例 1:
输入:s = “barfoothefoobarman”, words = [“foo”, “bar”]
输出:[0, 9]
解释:因为 words.length == 2 同时 words[i].length == 3,连接的子字符串的长度必须为 6。
子串 “barfoo” 开始位置是 0。它是 words 中以[“bar”, “foo”] 顺序排列的连接。
子串 “foobar” 开始位置是 9。它是 words 中以[“foo”, “bar”] 顺序排列的连接。
输出顺序无关紧要。返回[9, 0] 也是可以的。

示例 2:
输入:s = “wordgoodgoodgoodbestword”, words = [“word”, “good”, “best”, “word”]
输出:[]
解释:因为 words.length == 4 并且 words[i].length == 4,所以串联子串的长度必须为 16。
s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
所以我们返回一个空数组。

示例 3:
输入:s = “barfoofoobarthefoobarman”, words = [“bar”, “foo”, “the”]
输出:[6, 9, 12]
解释:因为 words.length == 3 并且 words[i].length == 3,所以串联子串的长度必须为 9。
子串 “foobarthe” 开始位置是 6。它是 words 中以[“foo”, “bar”, “the”] 顺序排列的连接。
子串 “barthefoo” 开始位置是 9。它是 words 中以[“bar”, “the”, “foo”] 顺序排列的连接。
子串 “thefoobar” 开始位置是 12。它是 words 中以[“the”, “foo”, “bar”] 顺序排列的连接。

提示:

1 <= s.length <= 10^4
1 <= words.length <= 5000
1 <= words[i].length <= 30
words[i] 和 s 由小写英文字母组成

思路:如果我们把每一个单词看成一个一个字母,问题就变成了找到「字符串中所有的字母异位词」。无非就是之前处理的对象是一个一个的字符,我们这里处理的对象是一个一个的单词。

代码如下:

		class Solution {
		public:
		    vector<int> findSubstring(string s, vector<string>& words)
		    {
		        vector<int> ret;
		
		        // hash1 记录 words 中的字符串
		        unordered_map<string, int> hash1;
		        for (const auto& str : words) hash1[str]++;
		
		        // words 中每个字符串的长度
		        int strLen = words[0].size();
		
		        // 遍历前 strLen 个即可
		        for (int i = 0; i < strLen; i++)
		        {
		            // hash2 记录组合成的字符串
		            unordered_map<string, int> hash2;
		            for (int left = i, right = i, count = 0; right < s.size(); right += strLen)
		            {
		                string in = s.substr(right, strLen);
		                hash2[in]++;
		
		                // count 维护有效字符串的数量,符合则 ++ 
		                if (hash2[in] <= hash1[in])
		                    count++;
		
		                // 出窗口判断
		                if (right - left + 1 > strLen * words.size())
		                {
		                    string out = s.substr(left, strLen);
		                    if (hash2[out] <= hash1[out])
		                        count--;
		                    hash2[out]--;
		                    left += strLen;
		                }
		
		                if (count == words.size())
		                {
		                    ret.push_back(left);
		                }
		            }
		        }
		
		        return ret;
		    }
		};

8. 最小覆盖子串

题目链接 -> Leetcode -76.最小覆盖子串

Leetcode -76.最小覆盖子串

题目:给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。
如果 s 中不存在涵盖 t 所有字符的子串,则返回空字符串 “” 。

注意:
对于 t 中重复字符,我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串,我们保证它是唯一的答案。

示例 1:
输入:s = “ADOBECODEBANC”, t = “ABC”
输出:“BANC”
解释:最小覆盖子串 “BANC” 包含来自字符串 t 的 ‘A’、‘B’ 和 ‘C’。

示例 2:
输入:s = “a”, t = “a”
输出:“a”
解释:整个字符串 s 是最小覆盖子串。

示例 3:
输入: s = “a”, t = “aa”
输出 : “”
解释 : t 中两个字符 ‘a’ 均应包含在 s 的子串中,
因此没有符合条件的子字符串,返回空字符串。

提示:
m == s.length
n == t.length
1 <= m, n <= 10^5
s 和 t 由英文字母组成

思路:研究对象是连续的区间,因此可以尝试使用滑动窗口的思想来解决。
如何判断当前窗口内的所有字符是符合要求的呢?

  • 我们可以使用两个哈希表,其中一个将目标串的信息统计起来,另一个哈希表动态的维护窗口内字符串的信息。
  • 当动态哈希表中包含目标串中所有的字符,并且对应的个数都不小于目标串的哈希表中各个字符的个数,那么当前的窗口就是⼀种可行的方案

代码如下:

		class Solution {
		public:
		    string minWindow(string s, string t) 
		    {
		        int hash1[128] = {0};
		
		        // kinds 统计 t 中字符类型的数量
		        int kinds = 0;
		        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++)
		        {
		            hash2[s[right]]++;
		
		            // 字符出现的次数必须等于hash1中的次数,窗口维护的有效字符类型才可以统计
		            if(hash2[s[right]] == hash1[s[right]]) count++;
		
		            while(count == kinds)
		            {
		                if(right - left + 1 < minLen)
		                {
		                    minLen = right - left + 1;
		                    begin = left;
		                }
		                char out = s[left];
		                left++;
		
		                if(hash2[out] <= hash1[out]) count--;
		                hash2[out]--;
		            }
		
		            
		        }
		
		        if(begin == -1) return "";
		        return s.substr(begin, minLen);
		    }
		};
转载请说明出处内容投诉
CSS教程_站长资源网 » 【算法专题】滑动窗口

发表评论

欢迎 访客 发表评论

一个令你着迷的主题!

查看演示 官网购买