目录
滑动窗口算法
滑动窗口的本质还是双指针，只不过滑动窗口的双指针，是同向双指针，两个指针并不回退，都是向同一个方向移动，如果发现两个指针都可以做到不回退，此时可以使用滑动窗口解决问题。
滑动窗口一般的套路就是：进窗口，判断，根据判断结果来决定是否出窗口，另外是更新结果，更新结果的时机不是固定的，要因题而论。
题目1:长度最小的子数组
题目链接：209. 长度最小的子数组 - 力扣（LeetCode）
思路1：暴力解法，枚举出所有的子数组，找出一下长度最小且满足条件的数组
思路1的实现：定义left、right，两层for循环，定义变量sum统计子数组的和，下面是伪代码
int len = Integer.MAX_VALUE;
for(int left =0;left<nums.length;left++){
for(int right =left;right<nums.length;right++){
sum+=nms[right];
if(sum>=target){
check(len,right-left+1);
//如果len<right-left+1,更新len的值
}
}
}
return len;
分析暴力解法，可以发现两个问题：当sum满足target要求时，right可以停止往后枚举了，因为right就算往后枚举，sum的要求仍然满足，并且子数组的长度是增加的，并不符合长度最小这个要求；另一个问题是，当枚举完一个符合要求的子数组后，left是往后移动一位，但是，right是否有必要再回到left这个位置？如果right回退，我们又要重新计算sum，但是在枚举上一种情况时，我们已经计算过和了，并不需要重新再计算一次，只需要把left位置的值减去即可。所以我们得出结论，left和right两个“指针”都只需要往同一个方向移动即可，这也就引出今天的主角：滑动窗口
思路2：滑动窗口，定义两个指针left、right，维护窗口边界。进窗口操作：sum+=num[right]，进窗口之后，判断sum的值是否满足条件，如果满足，此时需要更新len的结果，更新之后出窗口。注意：判断操作是循环的，因为出窗口之后，sum可能还是>=target，需要继续出窗口。
代码实现：
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int left = 0,right=0;
int sum = 0;
int len = Integer.MAX_VALUE;
while(right<nums.length){
//进窗口:
sum+=nums[right];
//判断,需要循环判断,因为left向后移动之后,sum也有可能还>=target
while(sum>=target){
//满足条件,更新结果
len = Math.min(len,right-left+1);
//出窗口
sum-=nums[left];
left++;
}
right++;
}
if(len==Integer.MAX_VALUE){
return 0;
}
return len;
}
}
题目2:无重复字符的最长子串
题目链接：3. 无重复字符的最长子串 - 力扣（LeetCode）
思路1：暴力枚举+哈希表：暴力枚举所有的子串，利用哈希表判断子串中是否有重复字符。
思路1的实现：定义left、right，两层for循环枚举出全部的子串，分别判断每个子串是否满足条件，下面是伪代码
for(int left=0;left<nums.length();left++){
for(int right=left;left<nums.length();right++){
char ch = s.charAt(right);
if(!hash.contains(ch)){
hash.put(ch);
} else{
//统计.....结果
break;
}
}
}
分析暴力解法，right位置出现重复字符时,left+1，right继续回退到left位置，但其实right并不需要回退，同样的，两个指针都是同一个方向移动，我们可以使用滑动窗口
思路2：滑动窗口，进窗口的操作是：把字符扔进哈希表，判断字符是否在哈希表中已经存在过，如果已经存在，需要出窗口，出窗口之后更新结果
代码实现：
class Solution {
public int lengthOfLongestSubstring(String s) {
char[] chars = s.toCharArray();
int[] hash = new int[128];
int left = 0;
int right = 0;
int len = 0;
while(right<s.length()){
//进窗口
hash[chars[right]]++;
while(hash[chars[right]]>1) {
//说明出现重复字符了,出窗口
hash[chars[left]]--;
left++;
}
//更新结果
len = Math.max(len,right-left+1);
right++;
}
return len;
}
}
题目3:最大连续1的个数
题目链接：1004. 最大连续1的个数 III - 力扣（LeetCode）
问题转换:找出最长的子数组,0的个数不超过k个
思路1：暴力解法+计数器，枚举出所有的子数组，计数器的作用是统计0的个数，
思路1的实现：伪代码如下
int len = 0;
for(int left=0;left<nums.length;left++){
int count = 0;
for(int right=left;left<nums.length){
if(nums[right]==0){
count++;
}
if(count>k){
//更新len
break;
}
}
}
分析暴力解法：枚举过程中，right其实没有必要回退到left位置，因为在上一趟遍历中我们已经统计过个数，在下一趟遍历的时候我们只需要根据left的位置是否为0来修改count的值，因此，两个指针都不用回退，可以使用滑动窗口的思想
思路2：滑动窗口，进窗口操作就是统计0的个数，接着判断个数是否大于k，如果大于k需要出窗口，出完窗口之后，才更新结果，因为出窗口后，k的个数才满足要求。
代码实现：
class Solution {
public int longestOnes(int[] nums, int k) {
int count = 0;
int left = 0, right = 0;
int len = 0;
while (right < nums.length) {
// 进窗口
if (nums[right] == 0) {
count++;
}
// 判断
while (count > k) {
// 需要出窗口
if (nums[left] == 0) {
count--;
}
left++;
}
// 更新结果
len = Math.max(len, right - left + 1);
right++;
}
return len;
}
}
题目4:将x减到0的最小操作数
题目链接：1658. 将 x 减到 0 的最小操作数 - 力扣（LeetCode）
分析题目要求：
如图：题目要我们返回的值是a+b，长度为a的子数组与长度为b的子数组元素之和恰好为x，并且a+b的值是最小的，正难则反，我们可以先求出n-(a+b)。
问题转换：求出最长的子数组的长度len，子数组满足：元素之和恰好为sum-x（sum为原数组nums的元素之和），求出这个长度值之后，直接返回n-len即可
思路1：暴力解法，枚举出所有的子数组，求出满足条件的长度最长的子数组即可
思路1的实现：伪代码如下：
int len = 0;
int curSum = 0;
for(int left =0;left<nums.length;left++){
for(int right=left;right<nums.length;right++){
if(curSum==sum-x){
//更新len
break;
}
}
}
return n-len;
思路2：滑动窗口
class Solution {
public int minOperations(int[] nums, int x) {
int sum = 0;
for (int i : nums) {
sum += i;
}
int len = -1;
int n = nums.length;
int target = sum - x;
int left = 0, right = 0;
int curSum = 0;
while (right < n) {
// 进窗口
curSum += nums[right];
while (curSum > target && left < n) {
//left可能越界
// 如果curSum>target,需要出窗口
curSum -= nums[left];
left++;
}
// 出完窗口之后,此时的结果才可能是正确的,
// 更新结果
if (curSum == target) {
len = Math.max(len, right - left + 1);
}
right++;
}
if (len == -1) {
return -1;
}
return n - len;
}
}
题目5:水果成篮
问题转换：求最长的子数组的长度，子数组满足：水果的种类<=2
思路1：暴力解法+哈希表，暴力枚举出所有的子数组，借助哈希表、计数器来判断水果种类是否超过2
思路2：滑动窗口+哈希表
代码实现：
class Solution {
public int totalFruit(int[] fruits) {
int n = fruits.length;
int[] hash = new int[n + 1];// 构建哈希表
int left = 0, right = 0;
int count = 0;
int len = 0;
while (right < n) {
// 进窗口
if (hash[fruits[right]] == 0) {
count++;
}
hash[fruits[right]]++;
while (count > 2) {
// 出窗口
hash[fruits[left]]--;
if (hash[fruits[left]] == 0) {
count--;//移出哈希表
}
left++;
}
// 更新结果
len = Math.max(len, right - left + 1);
right++;
}
return len;
}
}
题目6:找到字符串中所有的字母异位词
题目链接：438. 找到字符串中所有字母异位词 - 力扣（LeetCode）
思路1：暴力解法，先把p字符串的词频（字符出现的个数）丢进哈希表中，接着枚举字符串s，枚举出所有长度为len(字符串p的长度)的子串，每枚举一个子串就把该子串丢进一个哈希表中，比较两个哈希表对应字符的频次
思路2：滑动窗口+哈希表，进窗口的操作：把字符扔进哈希表中，何时出窗口?当right位置和left位置长度大于p字符串的长度，此时要出窗口，因为这道题的窗口大小是固定的，窗口大小就是p字符串的长度，出完窗口后，比较两个哈希表的内容，如果内容相同，就把结果扔进集合中
代码实现：
class Solution {
public List<Integer> findAnagrams(String s, String p) {
List<Integer> ret = new ArrayList<>();
int[] hash1 = new int[26];
int[] hash2 = new int[26];
//把p的字符频次扔进哈希表hash2中
for (int i = 0; i < p.length(); i++) {
char ch = p.charAt(i);
hash2[ch - 'a']++;
}
//滑动窗口
int left = 0, right = 0;
while (right < s.length()) {
//进窗口
char in = s.charAt(right);
hash1[in-'a']++;
//判断
if (right - left + 1 > p.length()) {
//出窗口
char out = s.charAt(left);
hash1[out-'a']--;
left++;
}
//更新结果
//比较两个哈希表
boolean flg = true;
for (int i = 0; i < 26; i++) {
if (hash1[i] != hash2[i]) {
//两个哈希表内容不同,不是想要的结果
flg = false;
}
}
if (flg) {
ret.add(left);
}
right++;
}
return ret;
}
}
优化：更新结果这里，比较两个哈希表需要遍历一遍哈希表，通过一个变量count，可以优化这个操作，count表示的是有效字符的个数，什么是有效字符？也就是p字符串出现过的字符
核心逻辑：
//进窗口操作
//.....
//进窗口后
if(hash1[in]<=hash2[in]){
count++;
}
//.....
//出窗口前
if(hash1[in]<=hash2[in]){
count--;
}
//出窗口
in和out表示要进窗口、出窗口的字符
代码实现：
class Solution {
public List<Integer> findAnagrams(String s, String p) {
List<Integer> ret = new ArrayList<>();
//哈希表长度26->题目说明了只有小写字母
int[] hash1 = new int[26];
int[] hash2 = new int[26];//p的哈希表
for (int i = 0; i < p.length(); i++) {
char ch = p.charAt(i);
hash2[ch - 'a']++;//a->0,b->1,c->2.........
}
//双指针
int left = 0, right = 0;
int count = 0;//统计窗口中有效字符的个数
while (right < s.length()) {
//进窗口
char in = s.charAt(right);
hash1[in - 'a']++;
if (hash1[in - 'a'] <= hash2[in - 'a']) {
count++;
}
//判断
if (right - left + 1 > p.length()) {
//需要出窗口
char out = s.charAt(left);
if (hash1[out - 'a'] <= hash2[out - 'a']) {
count--;
}
hash1[out - 'a']--;
left++;
}
if (count == p.length()) {
ret.add(left);
}
right++;
}
return ret;
}
}
题目7:串联所有单词的子串
题目链接：30. 串联所有单词的子串 - 力扣（LeetCode）
思路：滑动窗口+哈希表
这道题的思路和上一道题"找到字符串中所有的字母异位词"其实是一样的，为什么？
如果把字符串看成一个字母，如图，是不是就变成了找到字符串中所有的字母异位词这个问题？
不同点：
1、哈希表：创建的哈希表是<String,Integer>类型的
2、left和right指针的移动：每次移动len（words中字符串的长度）
3、滑动窗口的执行次数：执行len次
代码实现：
class Solution {
public List<Integer> findSubstring(String s, String[] words) {
List<Integer> ret = new ArrayList<>();
//1. 把words扔进哈希表中
HashMap<String, Integer> hash = new HashMap<>();
for (int i = 0; i < words.length; i++) {
hash.put(words[i], hash.getOrDefault(words[i], 0) + 1);
}
int len = words[0].length();
//执行len次滑动窗口
for (int i = 0; i < len; i++) {
int left = i, right = i;
int count = 0;//有效字符串的个数
HashMap<String, Integer> hashMap = new HashMap<>();
//滑动窗口
while (right + len <= s.length()) {
//进窗口+维护count
String in = s.substring(right, right + len);
hashMap.put(in, hashMap.getOrDefault(in, 0) + 1);
if (hashMap.get(in) <= hash.getOrDefault(in, 0)) {
count++;
}
//判断
while ((right - left + 1) > len * words.length) {
//需要出窗口+维护count
String out = s.substring(left, left + len);
if (hashMap.get(out) <= hash.getOrDefault(out, 0)) {
count--;
}
hashMap.put(out, hashMap.get(out) - 1);
left += len;
}
if (count == words.length) {
ret.add(left);
}
right += len;
}
}
return ret;
}
}
题目8:最小覆盖子串
题目链接：76. 最小覆盖子串 - 力扣（LeetCode）
解法：滑动窗口+哈希表，进窗口的操作就是让left位置的字符进入哈希表，在进窗口之后维护kinds(字符种类个数)，当两个哈希表中有效字符的种类相等时，此时要出窗口，出窗口之前维护kinds
代码实现：
class Solution {
public String minWindow(String ss, String tt) {
// 数组模拟哈希表
int[] hash1 = new int[128];
int[] hash2 = new int[128];// 保存t的频次
char[] s = ss.toCharArray();
char[] t = tt.toCharArray();
int count = 0;// t字符串中字符种类个数
// 保存t的频次
for (char ch : t) {
if (hash2[ch] == 0) {
count++;
}
hash2[ch]++;
}
// 滑动窗口启动
int left = 0, right = 0, kinds = 0;
int minLen = Integer.MAX_VALUE, begin = -1;
while (right < s.length) {
// 进窗口+维护kinds
char in = s[right];
hash1[in]++;
// 维护有效字符种类
if (hash1[in] == hash2[in]) {
kinds++;
}
// 判断,如果kinds==count,也就是说hash1有效字符种类和hash2一样
while (kinds == count) {
// 更新结果,起始位置和最短长度
if (right - left + 1 < minLen) {
minLen = right - left + 1;
begin = left;
}
// 出窗口+维护kinds
char out = s[left];
// 出之前判断有效字符种类
if (hash1[out] == hash2[out]) {
kinds--;
}
//出窗口
hash1[out]--;
left++;
}
right++;
}
if (begin == -1) {
return new String();
}
return ss.substring(begin, begin + minLen);
}
}