给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

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

提示：

• 1 <= target <= 10^9
• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^5

方法一：暴力法

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int result = 0;
            for(int i = 0;i < nums.length;i++){
                int sum = 0;
                int temp = 0;
                for(int j = i;j < nums.length;j++){
                    if(sum<target){
                        sum = sum + nums[j];
                        temp++;
                    }
                    else {
                        break;
                    }
                }
                if((result == 0 || temp < result) && sum >= target){
                    result = temp;
                }
            }
            return result;

    }
}

方法二：滑动窗口

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //滑动窗口思想
        int i = 0;
        int j = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for(;j<nums.length;j++){
            sum += nums[j];  //持续增加滑动窗口大小
            while(sum>=target){ //当滑动窗口中值的和>=目标值的时候，就找到了结果
                int len = j - i + 1; //获得当前滑动窗口长度
                result = len < result ? len : result;  //更新结果
                //接下来移动起始位置，将滑动窗口后移
                sum = sum - nums[i]; //将滑动窗口起始位置的值删去
                i++; //滑动窗口后移
            }
        }
        result = result != Integer.MAX_VALUE ? result : 0;
        return result;
        

    }
}

其他题目：

题目1：水果成篮

leetcode.cn/problems/fr…
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 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 <= 105
• 0 <= fruits[i] < fruits.length

方法一：暴力法

class Solution {
    public int totalFruit(int[] fruits) {  
        int result = 0;
            for(int i=0;i< fruits.length;i++){
                int sum = 0;
                int l1 = -1;
                int l2 = -1;
                int j = i;
                for(;j < fruits.length;j++){  //一次循环遍历完获得窗口的尾部
                    if(l1 == -1){
                        l1 = fruits[j];
                    }
                    else if(l2 == -1 && l1 != fruits[j]){
                        l2 = fruits[j];
                    }
                    if(fruits[j] == l1 || fruits[j] == l2){
                        sum++;
                    }
                    else{
                        break;
                    }
                }
                result = sum > result ? sum :result;
                if(j == fruits.length-1){
                    break;
                }


            }
            return result;
    }
}

方法二：滑动窗口

class Solution {
    public int totalFruit(int[] fruits) {  
        int result = 0;
            int i = 0;
            int j = 0;
            Map<Integer,Integer> map = new HashMap<>();
            for(;j < fruits.length;j++){
                map.put(fruits[j],map.getOrDefault(fruits[j],0)+1);
                while(map.size()>=3){
                    map.put(fruits[i],map.get(fruits[i])-1);
                    if(map.get(fruits[i]) == 0){
                        map.remove(fruits[i]);
                    }
                    i++;
                }
                result = result > (j-i+1) ? result : (j-i+1);
            }
            return result;
    }
}

题目2：最小覆盖子串

leetcode.cn/problems/mi…

class Solution {
    public String minWindow(String s, String t) {
        int i = 0;
            int j = 0;
            String result = "";
            int temp = Integer.MAX_VALUE;
            Map<Character, Integer> map = new HashMap<>();  //表示当前每个键需要多少个值，即每个字符需要几个
            Map<Character, Integer> map2 = new HashMap<>(); //表示本身每个键需要多少个值，即每个字符需要几个
            int value = 0;
            //将t存入哈希表中
            for(int k = 0;k<t.length();k++){
                map.put(t.charAt(k),map.getOrDefault(t.charAt(k),0)+1);
                map2.put(t.charAt(k),map.getOrDefault(t.charAt(k),0)+1);
            }

            for(;j<s.length();j++){
                if(map.containsKey(s.charAt(j))) //如果s中当前的元素 等于 t中的某个元素，则对应的map值-1
                {
                    char a = s.charAt(j);
                    map.put(s.charAt(j),map.get(s.charAt(j))-1);
                    if(map.get(s.charAt(j)) == 0){
                        value++; //当前字符数量已经满足条件
                    }
                }
                while (map.size() == value){  //当map中所有的值<=0，说明找完了，需要更新左指针
                    //首先判断当前结果是否是最优解
                    String st = s.substring(i,j+1);
                    if(st.length() < temp){
                        temp = st.length();
                        result = st;
                    }
                    //然后移动左指针
                    //首先看头指针是否 等于 t中的某个元素，是的话就重新加入到map
                    if(map2.containsKey(s.charAt(i))){
                        map.put(s.charAt(i),map.getOrDefault(s.charAt(i),0)+1);
                        //这里还要判断当前元素是否是多余的，即只需要一个但是有两个
                        if(map.get(s.charAt(i))>0){
                            value--;
                        }

                    }
                    i++;
                }
                }
            return result;

    }
}

这里思路没问题，只是代码还有优化的空间，后面二刷再看看。

总结滑动窗口思路：

1：初始化起始位置i和终止位置j
2：定义一个循环，移动终止位置
3：在这个循环中：
    （1）首先每循环一次，一定会扩充右边界，看每次扩充右边界后哪些值会改变
    （2）定义一个内循环，终止条件为刚好不满足题意的条件，这个时候就要移动左边界了，并且缩小滑动窗口，处理一下缩小窗口会改变的值
4：最后就是比较并返回结果
最最最重要的就是要：找到刚好不满足题意的终止条件，只要找到终止条件，基本上就能AC。