代码随想录day03-数组（长度最小的子数组）

209.长度最小的子数组

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

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

示例：

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

暴力解法： 

每个位置的元素开始，往后面加，>=target就换下一个元素

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //快慢双指针
        int slow=0;
        int count=0;
        int min=Integer.MAX_VALUE;
        for(int fast=0;fast<nums.length;fast++){
            count+=nums[fast];
            if (count>=target){
                min=Math.min(min,fast-slow+1);
                count=0;
                fast=slow;
                slow++;
            }
        }
        return min==Integer.MAX_VALUE?0:min;
    }
}

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

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int slow=0;
        int count=0;
        int min=Integer.MAX_VALUE;
        for(int fast=0;fast<nums.length;fast++){
            count+=nums[fast];
            while(count>=target){
                min = min < fast-slow+1 ? min:fast-slow+1;
                count -= nums[slow++];
            }
        }
        return min==Integer.MAX_VALUE?0:min;
    }
}

904. 水果成篮

找至多包含两种元素的最长子串，返回其长度

滑动窗口：

class Solution {
    public int totalFruit(int[] fruits) {
        int n = fruits.length;
        Map<Integer, Integer> cnt = new HashMap<Integer, Integer>();//创建一个空的哈希表

        int left = 0, ans = 0;
        for (int right = 0; right < n; ++right) {
            //把水果加入哈希表中，你可以这么看cnt.put(水果类型，水果个数)，key存储水果类型，而key对应的value存储对应的水果类型个数
            cnt.put(fruits[right], cnt.getOrDefault(fruits[right], 0) + 1);
            //当哈希表中的键值大于2时，也就是水果类型大于2时，进入while循环
            while (cnt.size() > 2) {
                //从哈希表中减去一个key==fruits[left]类型的水果，当key==fruits[left]这种类型的水果数等于0时，删除这种类型水果
                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;
    }
}

76. 最小覆盖子串(不会)

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

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

class Solution {
    public String minWindow(String s, String t) {
        if (s == null || s == "" || t == null || t == "" || s.length() < t.length()) {
            return "";
        }
        int[] need = new int[128];
        int[] have = new int[128];
        for (int i = 0; i < t.length(); i++) {
            need[t.charAt(i)]++;
        }
        int left = 0, right = 0, min = s.length() + 1, count = 0, start = 0;
        while (right < s.length()) {
            char r = s.charAt(right);
            if (need[r] == 0) {
                right++;
                continue;
            }
            if (have[r] < need[r]) {
                count++;
            }
            have[r]++;
            right++;
            while (count == t.length()) {
                if (right - left < min) {
                    min = right - left;
                    start = left;
                }
                char l = s.charAt(left);
                if (need[l] == 0) {
                    left++;
                    continue;
                }
                if (have[l] == need[l]) {
                    count--;
                }
                have[l]--;
                left++;
            }
        }
        if (min == s.length() + 1) {
            return "";
        }
        return s.substring(start, start + min);
    }
}