算法题总结（三）——滑动窗口

滑动窗口

滑动窗口：就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果

时间复杂度：每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

#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

在本题中实现滑动窗口，主要确定如下三点：

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？

窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //求最短滑动窗口，限制条件:窗口内的元素和大于target

        int ans=Integer.MAX_VALUE;
        int left=0;
        int sum=0;
        for(int right=0;right<nums.length;right++)
        {
            sum+=nums[right];           //右端一直移动直到满足条件
            while(sum>=target)     //满足限制条件     
            {
                if((right-left+1)<ans){   //满足条件的情况下，找最佳结果，即找最短的窗口
                    ans=right-left+1;
                }
                sum-=nums[left];         //左端滑动,找最小的距离，直到不满足条件
                left++;
            }

        }
        return ans==Integer.MAX_VALUE?0:ans;
    }
}

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] 这五棵树。

class Solution {
    public int totalFruit(int[] fruits) {
        //限制条件：最多有两种类型的树
        int ans=0;
        Map<Integer,Integer> cnt =new HashMap<>();
        int left=0;
        for(int right=0;right<fruits.length;right++)
        {
            //本来是符合限制条件，所以一直加到不满足限制条件
            cnt.put(fruits[right],cnt.getOrDefault(fruits[right],0)+1);

            while(cnt.size()>2)   //不符合限制条件
            {
                //左窗口移动，直到满足条件
                cnt.put(fruits[left],cnt.get(fruits[left])-1); 
                if(cnt.get(fruits[left])==0)
                {   
                    cnt.remove(fruits[left]);
                }
                left++;
            }

            //满足条件的情况下，找最佳结果
            ans=Math.max(ans,right-left+1);
        }
        return ans;
    }
}

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

#3、无重复字符的最长子串

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

移动过程：如果在left的右边已经有这个元素，left要移动到这个元素的右边开始，并把这个元素入map。如果这个元素在left的右边没有出现过，就直接把这个元素入map就可以。

lass Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s.length()==0)
            return 0;
        //使用一个哈希表，记录一个元素最近出现的位置，也就是最后出现的位置
        Map<Character,Integer> map = new HashMap<>();
        int left=0;
        int max=0;
        for(int i=0;i<s.length();i++)  //双指针，也是左右字符串移动
        {
            if(map.containsKey(s.charAt(i)) && map.get(s.charAt(i))>=left)  //如果在left的右边已经有这个元素的
            {
                left=map.get(s.charAt(i))+1; //left要从这个元素的右边开始
            }

            map.put(s.charAt(i),i);
            max=Math.max(max,i-left+1);
        }
        return max;

    }
}

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 的子串中，
因此没有符合条件的子字符串，返回空字符串。

此题虽然是困难题，但是和209的思路是一样的！

都是求长度最小的子数组或者子串，这道题因为要输出最小的子串，所以定义两个变量来记录最小的子串的左边和右边。

class Solution {
    Map<Character,Integer> tmap=new HashMap<>();
    Map<Character,Integer> smap=new HashMap<>();
    public String minWindow(String s, String t) {
        int slen=s.length();
        int tlen=t.length();
        for(int i=0;i<tlen;i++)
        {
            tmap.put(t.charAt(i),tmap.getOrDefault(t.charAt(i),0)+1);
        }
        int left=0;
        int ans=Integer.MAX_VALUE;
        int ansL=-1;
        int ansR=-1;  //记录最小子串的边界
        for(int right=0;right<slen;right++)
        {
            Character c=s.charAt(right);
            smap.put(c,smap.getOrDefault(c,0)+1);
            while(check()) //如果覆盖
            {
                if(right-left+1<ans)
                {
                    ans=right-left+1;
                    ansL=left;
                    ansR=right;
                }
                //移动左边界
                smap.put(s.charAt(left),smap.get(s.charAt(left))-1);
                left++;
            }
        }
        return ansL==-1?"": s.substring(ansL,ansR+1);
    }
    //检查是否覆盖
    public boolean check()
    {
        Set<Character> tset=tmap.keySet();
        for(Character c:tset)
        {
            if(tmap.get(c)>smap.getOrDefault(c,0))
                return false;
        }
        return true;

    }

滑动窗口总结

1、对于一开始不满足限制条件的，一般是求满足条件的最小值问题。

两端都从起始位置开始，右端一直加到满足条件，然后在满足条件下进行循环，找最佳结果并进行左端移动，

2、对于一开始是满足条件的，一般是求满足条件的最大值问题。

两端都从起始位置开始，右端一直加到不满足条件，然后在不满足条件的情况下循环，左端移动，直到满足条件后，再求最佳结果。