0014【数组】中等LeetCode209.长度最小的子数组

目录

• 1.题目描述

  • 难度：中等

  • 示例

  • 提示

  • 进阶

• 2.题目解答

  • 方法一：滑动窗口相加型

  • 方法二：滑动窗口相减型

  • 方法三：前缀和+二分查找

1.题目描述

难度：中等

给定一个含有 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 <= 10^9
• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^5

进阶

如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

2.题目解答

方法一：滑动窗口相加型

解题思路
1.窗口就是满足其和 ≥ s 的长度最小的连续子数组。
2.窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。
3.窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。
4.滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置，从而将O(n^2)暴力解法降为O(n)。
5.时间复杂度O(n)，空间复杂度O(1)。

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

方法二：滑动窗口相减型

解题思路
1.窗口满足的条件：target减去当前窗口之和≤0。
2.时间复杂度O(n)，空间复杂度O(1)。

public class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int start = 0;
        int result = Integer.MAX_VALUE;
        for (int end = 0; end < nums.length; end++) {
            target -= nums[end];
            while (target <= 0) {
                result = Math.min(result, (end - start + 1));
                target += nums[start++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

方法三：前缀和+二分查找

解题思路
1.创建数组sums用于存储数组nums的前缀和，其中sums[i]表示从nums[0]到nums[i−1]的元素和。
2.因为这道题保证了数组中每个元素都为正，所以前缀和一定是递增的，这一点保证了二分的正确性。如果题目没有说明数组中每个元素都为正，这里就不能使用二分来查找了。
3.只需要找到sums[end]-sums[start]>=target，那么 end-start 就是满足的连续子数组，但不一定是最小的，所以要继续找，直到找到最小的为止。
4.求 sums[end]-sums[start]>=target 等价于求 sums[start]+target<=sums[end]，因为数组sums中的元素是递增的，也就是排序的，只需要求出 sum[start]+target 的值，然后使用二分法查找即可找到这个end。

public class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int[] sums = new int[nums.length + 1];
        for (int i = 1; i <= nums.length; i++) {
            sums[i] = sums[i - 1] + nums[i - 1];
        }

        int result = Integer.MAX_VALUE;
        for (int start = 0; start < sums.length; start++) {
            int sumsEnd = sums[start] + target;
            int end = Arrays.binarySearch(sums, sumsEnd);
            if (end < 0) {
                // 等价于按位取反 end = ~end;
                end = -end - 1;
            }
            if (end < sums.length) {
                result = Math.min(result, end - start);
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}