209.长度最小的子数组

需求

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

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

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

示例 2：
输入：target = 4, nums = [1,4,4]
输出：1

示例 3：
输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：
1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

版本1

看了需求后, 很明显这里需要使用 滑动窗口, 简易的先写出第一个版本:

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

这段代码解释如下:

public int minSubArrayLen(int target, int[] nums) {
        // 初始化结果为最大整数值，用于后续比较
        int resultLength = Integer.MAX_VALUE;
        // 慢指针，用于记录子数组的起始位置
        int slow = 0;
        // 用于累加子数组元素的和
        int sum = 0;
        // 快指针，用于遍历数组
        for (int fast = 0; fast < nums.length; fast++) {
            // 将快指针指向的元素加入累加和
            sum += nums[fast];
            // 当累加和大于等于目标值时，尝试缩小子数组长度
            while (sum >= target) {
                // 更新结果为当前子数组长度和之前结果的较小值
                resultLength = Math.min(resultLength, fast - slow + 1);
                // 移动慢指针，并减去其指向的元素值，以缩小子数组
                sum -= nums[slow++];
            }
        }
        // 如果结果仍为最大整数值，说明没有找到符合条件的子数组，返回0；否则返回结果
        return resultLength == Integer.MAX_VALUE ? 0 : resultLength;
    }

运行后 很丝滑:

版本2

上面的版本运行后, 通过了所有的测试用例, 但是, 我想有个地方可以优化一下, 就是:

上图的红框内, 如果代码进到红框内, 就说明已经找到了满足条件的子数组了, 这时候通过 resultLeangth = Math.min(resultLeangth, fast - slow + 1); 来确定最小的子数组长度, 其实 这里当为 1 的时候就可以返回了, 因为根据题意, 其实只要有满足条件的子数组, 那么返回值必然是满足大于等于1的, 这里要的是最小的, 那么 我们加个判断, 当是1直接返回就OK.

修改后的代码如下:

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

运行结果如下:

结尾

以上 是我对长度最小的子数组的一些遐想和延伸, 可能不是最优解, 但是算法的优化嘛 本身就是一个思索的过程, 能在这个思索和迭代的过程中有所收获和乐趣就是在成长了, 欢迎大家一起来交流更多的解答…