滑动窗口法

整数数组中不定长滑动窗口法的应用

1、长度最小的子数组

2、水果成篮

1、力扣209题:给定一个含有 n 个正整数的数组和一个正整数 target 。找出该数组中满足其总和大于等于 target 的长度最小的 子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

方法一 暴力求解法

列举所有的子数组判断是否满足条件,在满足条件时,更新最小子数组的长度。

public int minSubArrayLen(int target, int[] nums) {
        // 初始化变量minLength,将其设置为比nums.length大的数值,防止当前数组的所有子数组元素不能满足条件
        int minLength = nums.length + 1;
        int sum;
        for(int start = 0;start < nums.length;start++){
            sum = 0;
            for(int end = start;end < nums.length;end++){
                sum = sum + nums[end];
                if(sum >= target){
                    minLength = Math.min(minLength,end - start + 1);
                    break; // 因为这里是求得是最小长度,比当前end还大的索引值不需要再判断了
                }
            }
        }
        //若minLength = nums.length,说明未被更新,数组中所有的子数组都不满足条件
        return minLength == nums.length + 1 ? 0 : minLength;
    }

方法二 滑动窗口法

在方法一中存在很多的计算浪费,例如每次更新start索引时,均会将sum置零,更新start后,再继续做累加造成时间空间的浪费;还有在当前start下,end可能更新到了nums.length - 1这个索引了,并且这个区间[start,nums.length - 1]并不满足条件,那说明已经没有再继续更新start得必要性了,但方法一这种方法还是会继续检查造成时间空间的浪费。

滑动窗口法就避免了上面得两种情况,不会在每次更新start索引时,将sum置零了,而是将移除当前子数组的元素减去,并且当前start下,end可能更新到了nums.length - 1这个索引了,并且这个区间[start,nums.length - 1]并不满足条件这种情况后,不再检查后面的子数组了。

public int minSubArrayLen(int target, int[] nums) {
       int start = 0;
       int end = 0;
       int sum = 0;
       int minLength = nums.length + 1;
       while(start <= end && end < nums.length){
        sum = sum + nums[end];
        // 求最小长度的子数组,只有在满足条件的时候才能更新!
        while(sum >= target){
            // 满足条件,先更新minLength
            minLength = Math.min(minLength,end - start + 1);
            // 在检查是否还可以缩小子数组,即更新start
            sum = sum - nums[start];
            start++;
        }
        end++;
       }
       return minLength == nums.length + 1 ? 0 : minLength;
    }

2、力扣904题:你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个]篮子能够装的水果总量没有限制。你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。

方法一 暴力求解发

列举从每棵树开始采摘的情况,在符合条件时更新maxNumber,不符合条件,则进入下一个树开始采摘。

public int totalFruit(int[] fruits) {
        Set<Integer> set = new HashSet<>();
        int maxNumber = 0;
        for(int start = 0;start < fruits.length;start++){
            // 确保每次从不同的树开始采摘时集合set是空的
            set.clear();
            for(int end = start;end < fruits.length;end++){
                set.add(fruits[end]);
                if(set.size() > 2){
                    // 一旦发现不符合条件之后,立马跳出当前循环,不能进行更新maxNumber操作
                    break;
                }
                maxNumber = Math.max(maxNumber,end - start + 1);
            }
        }
        return maxNumber;
    }

方法二 滑动窗口法

在方法一中存在浪费,例如当前start索引处开始采摘,在fruits.length - 1出停下来,并且此时会更新maxNumber,那么后面的start索引开始的区间则不用检查了,因为maxNumber不会更新了;还有如果在start索引处开始,end索引处结束,并且在此时的start+k开始也在end索引处结束,那么start+1 - start+k索引开始则不需要检查了。

 public int totalFruit(int[] fruits) {
        int start = 0;
        int end = 0;
        int maxNumber = 0;
        Map<Integer,Integer> map = new HashMap<>();
        while(end < fruits.length){ // 当end == fruits.length - 1,则说明maxNumber不会更新了,即第一种浪费
            if(!map.containsKey(fruits[end])){
                // 跳过start更新但不会更新maxNumber的start,即第二种浪费
                while(map.size() > 1){
                    map.put(fruits[start],map.get(fruits[start]) - 1);
                    if(map.get(fruits[start]) == 0){
                        map.remove(fruits[start]);
                    }
                    start++;
                }
            }
            map.put(fruits[end],map.getOrDefault(fruits[end],0) + 1);
            maxNumber = Math.max(maxNumber,end - start + 1); 
            end++;  
        }
        return maxNumber;
    }

滑动窗口优化算法

public int totalFruit(int[] fruits) {
        int start = 0;
        int end = 0;
        int maxNumber = 0;
        Map<Integer,Integer> map = new HashMap<>();
        while(end < fruits.length){
            if(!map.containsKey(fruits[end])){
                while(map.size() > 1){
                    int minIndex = fruits.length;
                    // 遍历两次就可以 而上种做法可能需要多次
                    for(Integer i : map.values()){
                        minIndex = Math.min(minIndex,i);
                    }
                    map.remove(fruits[minIndex]);
                    start = minIndex + 1;
                }
            }
            // 由存储key的数量变为存储key的索引值
            map.put(fruits[end],end);
            maxNumber = Math.max(maxNumber,end - start + 1); 
            end++;  
        }
        return maxNumber;
    }