【算法专题】滑动窗口

滑动窗口

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);
		    }
		};