算法通关村——滑动窗口高频问题

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

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

1.1 滑动窗口

找到最长字串需要找到字串的首尾位置，而这个首尾位置就是滑动窗口的大小。题目中出现了重复，一般是想到使用hashmap作为存储元素，而这个里面可以将字符串的相应的字符作为k，然后它的下标作为value，一旦遇到有重复字符的，就将左窗口移到当前的位置的右边一位，作为新的字符串的开始位置。

    public int lengthOfLongestSubstring(String s) {
        if(s.length() == 0) return 0;
        // 左窗口开始
        int left = 0;
        int max = 0;
        // 存放k：字符，v：字符下标
        HashMap<Character,Integer> hashMap = new HashMap<>();
        for(int right = 0;right<s.length();right++){
            // 里面包含当前字符，需要移动左窗口的位置
            if(hashMap.containsKey(s.charAt(right))){
                left = Math.max(left,hashMap.get(s.charAt(right))+1);
            }
            // 不包含，就将元素和它的下标添加
            hashMap.put(s.charAt(right),right);
            // 比较大小
            max = Math.max(max,right-left+1);
        }
        return max;
    }

2. 至多包含两个不同字符的最长子串

给定一个字符串 s ，找出 至多 包含两个不同字符的最长子串 t ，并返回该子串的长度，这就是LeetCode159题。例如：
输入: “eceba”
输出: 3
解释: t 是 “ece”，长度为3。

2.1 滑动窗口

字符串依然是需要首尾位置，采用滑动窗口，和第一题类似，不过这一题的关键在于字符串是两个不同的字符，判断字符是否重复可以使用hashmap，而问题在于如何判断只有两个字符，出现第三个字符应该如何去除之前的字符。
可以使用 int del_idx = Collections.min(hashmap.values());
hashmap.remove(s.charAt(del_idx));

public int lengthOfLongestSubstringTwoDistinct(String s) {
        if (s.length() <= 2) {
            return s.length();
        }
        // 最大长度
        int maxLength = 2;
        int left = 0;
        int right = 0;

        HashMap<Character, Integer> map = new HashMap<>();
        while (right < s.length()) {
            // map长度小于3，意味着还没出现第三个不一样的字符，此时可以继续添加，更改对于元素下标
            if(map.size() < 3) {
             map.put(s.charAt(right), right++);
            }
            // map长度等于3，此时出现了第三个不一样的字符，需要删除一个最小位置下标的字符，然后移动左指针到当前删除下标的下一个位置
            if(map.size() == 3){
                int del_idx = Collections.min(map.values());
                map.remove(s.charAt(del_idx));
                left = del_idx + 1;
            }
            maxLength = Math.max(maxLength, right - left);
        }
        return maxLength;
    }

3. 至多包含 K 个不同字符的最长子串

LeetCode340题。
题目的完整要求是：给定一个字符串 s，找出 至多 包含 k 个不同字符的最长子串T。示例：
输入: s = “eceba”, k = 2
输出: 3
解释: 则 T 为 “ece”，所以长度为 3。

3.1 滑动窗口

这一题和上面一样，只不过是将2替换成了k，判断的是否改成k就可以。

    public int lengthOfLongestSubstringKDistinct(String s, int k) {
        if (s.length() < k) return 0;
        int left = 0;
        int right = 0;
        HashMap<Character, Integer> map = new HashMap<>();
        int maxLength = k;
        while (right < s.length()) {
            if (map.size() < k+1) {
                map.put(s.charAt(right), right++);
            }
            if(map.size() == k+1){
                int del_idx = Collections.min(map.values());
                map.remove(s.charAt(del_idx));
                left = del_idx + 1;
            }
            maxLength = Math.max(maxLength, right - left);
        }
        return maxLength;
    }

4. 长度最小的子数组

长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

4.1 滑动窗口

这一题主要思路就是计算滑动窗口区间内的元素和，如果元素和小于目标值，可以继续添加，如果元素和大于目标值，那么就需要将左窗口位置的元素从元素和里面去除，然后移动指针，直到元素和小于目标值。

  public int minSubArrayLen(int target, int[] nums) {
        int left =0;
        int right =0;
        int minLength = Integer.MAX_VALUE;
        int sum = 0;
        while(right<nums.length){
            sum += nums[right++];
            while(sum >= target){
                minLength = Math.min(minLength,right-left);
                sum = sum -  nums[left++];
            }
        }

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

5. 盛最多水的容器

盛最多水的容器
给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
说明：你不能倾斜容器。

输入：[1,8,6,2,5,4,8,3,7]
输出：49

5.1 滑动窗口

这一题思路还是很清晰的，首先定义两个指针分别指向首尾，然后向中间移动，移动过程中需要判断左右两个高度，选出最短的，然后计算面积。

 public int maxArea(int[] height) {
        int left = 0;
        int right = height.length - 1;
        int maxAre = 0;
        while(left < right){
            maxAre = 
            height[left] < height[right] ? 
            Math.max(maxAre,(right-left) * height[left++] ):
            Math.max(maxAre,(right-left) * height[right--]);
        }
        return maxAre;
    }