【LeetCode数组#4滑动窗口】长度最小的子数组+子数组最大平均数I

长度最小的子数组

力扣题目链接(opens new window)

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

示例：

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

初见思路

题目给的输入有两个，一个是数组nums，另一个是目标和target。我们需要找到数组中的一个连续子数组，其相加和为target，且所需数组元素最少

两个问题：

1、寻找一个子数组，相加结果等于target

2、该子数组是所有可能数组中最小的

双指针好像不太行，用暴力破解试试

那就用两层for循环，第一层用于控制子数组的起始位置，第二层是子数组的结束位置【感觉本质上还是双指针。。。】

Java版（超时）

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int sum = 0;
        int subLeng = 0;//用于记录子串长度
        int res = Integer.MAX_VALUE;//将res设置为int的最大值
        for(int i = 0; i < nums.length; i++){
            sum = 0;
            for(int j = i; j < nums.length; j++){
                sum += nums[j];
                if(sum >= target){
                    subLeng = j - i + 1;
                    res = res < subLeng ? res : subLeng;//满足最小子串条件的才保留，显然如果出现subLeng一定会保存的因为不可能有比res大的值
                    break;
                }
            }
        }
        return res == Integer.MAX_VALUE ? 0 : res;//判定当前res是否还为初始值，是就输出0
    }
}

不负众望的超时了，这也正常，毕竟两个for循环已经是O(n*n)的时间复杂度了

常规思路

这里就需要使用数组操作中的一个重要方法：滑动窗口

其本质上还是需要两个玩意去代表子数组的起始和结束位置

只不过使用滑动窗口方法我们可以在一个for循环中就实现上述功能，从而优化了时间复杂度

上面的描述更像双指针了，实际上滑动窗口确实就是双指针的一个变种，或者说只要你乐意，在一个数组上操控两个下标的方法都可以是双指针。

那么怎么做呢？

既然是双指针，那么肯定先确定两个指针各自需要干什么

设这里有两个指针left、right，分别表示窗口的左边界和右边界

和之前的双指针用法类似，将某个指针放入for循环中作为遍历时的下标【那肯定是右边界比较合适】

当for循环不断移动右边界的位置时，我们同时计算两个边界内（即窗口内）的数的和

如果当前窗口中元素的和满足target，记录下其长度，与res比较【res的初始值设为整型下的最大值】

如果当前子串长度小于res，那么将更新res为当前子串的长度值【肯定更新啊，res都设成最大了，来什么值都会更新的】

然后移动左边界left，继续计算，不满足条件就移动右边界

总而言之，就是当条件不满足时，移动右边界去遍历整个数组，遇到条件满足的子数组，计算并更新res，然后移动左边界，重复上述过程。

以题目中的示例来举例，s=7， 数组是 2，3，1，2，4，3，来看一下查找的过程：

解题模板

滑动窗口的代码中的关键点如下：

• 滑动窗口算法是基于双指针思想的一种算法
• 用于保存记录窗口内数值和的变量res应该设置为整型的最大值
• 在while中缩小窗口大小

c++版

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left = 0;
        int sum = 0;
        int sumLen = 0;
        int res = INT_MAX;
        for(int right = 0; right < nums.size(); ++right){
            sum += nums[right];//累加当前窗口内的值（因此right要从0开始）
            while(sum >= target){//窗口内的和大于target，记录当前窗口大小
                sumLen = right - left + 1;//要加1，因为right和left都是从0开始的
                res = min(sumLen, res);//更新当前最小结果
                //实现窗口"滑动"
                // left++;//移动左指针，缩小窗口
                sum -= nums[left];//sum -= nums[left++];
                left++;
            }
        }
        return res == INT_MAX? 0 : res;
    }
};

二刷问题：

1、滑动窗口的原理遗忘

主要是怎么滑的给忘了，触发窗口滑动的情况应该是当前窗口内的值满足题目条件

2、滑动窗口的实现

本质上还是双指针，并且是一个指针在循环外的那种情况

左指针只有在窗口满足缩小条件时才会移动（要注意，在判断条件时必须使用while，因为窗口不可能只滑动一次，这个过程是连续的）

3、关于三目运算符

其本质上还是类似于if条件语句，因此需要使用"=="

例如

return res == INT_MAX? 0 : res;//判断res是否满足三目运算符中的条件
return res = INT_MAX? 0 : res;//错误用法

三刷问题：

1、窗口滑动时是连续的，因此要使用while而不是if

2、记录窗口长度的变量要和记录结果变量分开，不然有可能取到的不是最小值

int subLen = 0;
int res = INT_MAX;

Java版

ps：

• 取最大值res使用Integer.MAX_VALUE
• 使用Math.min比较并更新res（Java版）
• Java下三目运算符：(关系表达式) ? 表达式1：表达式2；

先执行关系表达式，看其结果是true还是false
如果是true，则执行表达式1
如果是false，则执行表达式2

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int sum = 0;
        int subLeng = 0;
        int left = 0;
        int res = Integer.MAX_VALUE;//将res设置为int的最大值
        for(int right = 0; right < nums.length; right++){
            sum += nums[right];//累加当前窗口内的数值
            while(sum >= target){//当和大于等于target时，记录并更新res
                subLeng = right - left + 1;
                res = Math.min(res, subLeng);//更新res
                sum -= nums[left++];//移动左边界缩小窗口，此处为算法核心
            }
        }
        return res == Integer.MAX_VALUE ? 0 : res;//判定当前res是否还为初始值，是就输出0
    }
}

Python版

ps：

• Python中res需要取无限大的值，用float("inf")实现
• range(len(nums))生成用于遍历的迭代体
• 比较子串长度时使用min函数
• 注意Python下三目运算符的写法：[statement_1] if [expression] else [statement_2]

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        sum = 0
        left = 0  # 窗口左边界
        res = float("inf")  # 无限大的数，相当于java中的Integer.MAX_VALUE
        for right in range(len(nums)):
            sum += nums[right]  # 累加窗口内的值
            while sum >= target:
                res = min(res, right - left + 1)  # 比较当前子串和res的长度，取最小值
                sum -= nums[left]
                left += 1
        return 0 if res == float("inf") else res  # 判断res是否为初值

子数组最大平均数 I

代码

class Solution {
public:
    double findMaxAverage(vector<int>& nums, int k) {
        int sum = 0;
        int maxSum = INT_MIN;
        int left = 0;

        for(int right = 0; right < nums.size(); right++){
            sum += nums[right];
            if(right - left + 1 == k){//窗口大小到达k后，更新最大值
                maxSum = max(maxSum, sum);
                sum -= nums[left];
                left++;
            }
        }
        //最后计算平均值，分子分母均强转为double
        return static_cast<double>(maxSum) / static_cast<double>(k);
    }
};