滑动窗口题目：长度最小的子数组

题目

标题和出处

标题：长度最小的子数组

出处：209. 长度最小的子数组

难度

5 级

题目描述

要求

给定一个正整数数组 $\text{nums}$ 和一个正整数 $\text{target}$，返回元素和大于等于 $\text{target}$ 的连续子数组 ${\text{[nums}}_{\text{l}}{\text{, nums}}_{\text{l + 1}}{\text{, ..., nums}}_{\text{r - 1}}{\text{, nums}}_{\text{r}}\text{]}$ 的最小长度。如果不存在符合条件的子数组，返回 $\text{0}$。

示例

示例 1：

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

示例 2：

输入：$\text{target = 4, nums = [1,4,4]}$
输出：$\text{1}$

示例 3：

输入：$\text{target = 11, nums = [1,1,1,1,1,1,1,1]}$
输出：$\text{0}$

数据范围

• $\text{1}\le \text{target}\le {\text{10}}^{\text{9}}$
• $\text{1}\le \text{nums.length}\le {\text{10}}^{\text{5}}$
• $\text{1}\le \text{nums[i]}\le {\text{10}}^{\text{5}}$

进阶

如果你已经实现 $\text{O(n)}$ 时间复杂度的解法, 请尝试实现 $\text{O(n log n)}$ 时间复杂度的解法。

解法一

思路和算法

由于数组 $\text{nums}$ 中的元素都是正整数，因此对于任意子数组，在子数组的任意一端添加元素（即增加子数组的长度）后子数组中的元素和一定增加，在子数组的任意一端删除元素（即减少子数组的长度）后子数组中的元素和一定减少。

考虑数组 $\text{nums}$ 的两个不同下标 ${\text{end}}_1$ 和 ${\text{end}}_2$，其中 ${\text{end}}_1<{\text{end}}_2$，分别以这两个下标作为结束下标，寻找元素和大于等于 $\text{target}$ 的最短子数组，将这两个最短子数组的开始下标分别记为 ${\text{start}}_1$ 和 ${\text{start}}_2$，则必有 ${\text{start}}_1\le {\text{start}}_2$（否则对于任意 ${\text{start}}_2<{\text{start}}_3\le {\text{start}}_1$，下标范围 $[{\text{start}}_3,{\text{end}}_2]$ 的子数组的元素和大于等于 $\text{target}$，且长度小于下标范围 $[{\text{start}}_2,{\text{end}}_2]$ 的子数组）。

因此，可以使用变长滑动窗口寻找数组 $\text{nums}$ 中的元素和大于等于 $\text{target}$ 的最短子数组。用 $[\text{start},\text{end}]$ 表示滑动窗口，初始时 $\text{start}=\text{end}=0$。将滑动窗口的右端点 $\text{end}$ 向右移动，移动过程中维护滑动窗口的左端点 $\text{start}$，对于每个 $\text{end}$ 寻找元素和大于等于 $\text{target}$ 的最小滑动窗口。

用 $\text{sum}$ 表示滑动窗口中的元素和。对于每个右端点 $\text{end}$，执行如下操作。

1. 将 $\text{sum}$ 的值增加 $\text{nums}[\text{end}]$。

2. 如果 $\text{sum}\ge \text{target}$，则当前滑动窗口 $[\text{start},\text{end}]$ 中的子数组为元素和大于等于 $\text{target}$ 的子数组，其长度为 $\text{end}-\text{start}+1$，使用当前子数组的长度更新子数组的最小长度，然后将 $\text{sum}$ 的值减少 $\text{nums}[\text{start}]$，将 $\text{start}$ 向右移动一位，重复该操作直到 $\text{sum}<\text{target}$。

遍历结束之后，可以得到数组 $\text{nums}$ 中的元素和大于等于 $\text{target}$ 的子数组的最小长度。

代码

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

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。滑动窗口的左右端点最多各遍历数组 $\text{nums}$ 一次。

• 空间复杂度：$O(1)$。

解法二

思路和算法

由于数组 $\text{nums}$ 中的元素都是正整数，因此子数组元素和的最大值为整个数组的元素和。如果整个数组的元素和小于 $\text{target}$，则不存在元素和大于等于 $\text{target}$ 的子数组，返回 $0$。如果整个数组的元素和大于等于 $\text{target}$，则一定存在元素和大于等于 $\text{target}$ 的子数组。

用 $k$ 表示数组 $\text{nums}$ 的元素和大于等于 $\text{target}$ 的子数组的最小长度。由于数组 $\text{nums}$ 中的元素都是正整数，因此一定存在长度为 $k+1$ 的子数组的元素和大于等于 $\text{target}$（当 $k$ 等于数组 $\text{nums}$ 的长度时例外），且一定不存在长度小于 $k$ 的子数组的元素和大于等于 $\text{target}$。因此，这道题是二分查找判定问题，需要找到最小长度。

当子数组长度 $x$ 固定时，可以使用长度为 $x$ 的定长滑动窗口遍历数组 $\text{nums}$，得到每个长度为 $x$ 的子数组的元素和，并判断是否存在长度为 $x$ 且元素和大于等于 $\text{target}$ 的子数组。具体做法如下。

1. 用 $\text{sum}$ 表示长度为 $x$ 的子数组的元素和，初始时 $\text{sum}$ 等于最左侧的 $x$ 个元素之和。

2. 对于 $x\le i<n$，当子数组的下标范围从 $[i-x,i-1]$ 移动到 $[i-x+1,i]$ 时，$\text{nums}[i-x]$ 移出子数组，$\text{nums}[i]$ 移入子数组，因此 $\text{sum}$ 的变化是减少 $\text{nums}[i-x]$ 并增加 $\text{nums}[i]$。

3. 遍历所有的长度为 $x$ 的子数组之后，即可得到每个长度为 $x$ 的子数组的元素和，并判断是否存在长度为 $x$ 且元素和大于等于 $\text{target}$ 的子数组。

用 $\text{low}$ 和 $\text{high}$ 分别表示二分查找的下界和上界。由于子数组至少有 $1$ 个元素，因此 $\text{low}$ 的初始值等于 $1$；由于子数组的最大长度为整个数组的长度，因此 $\text{high}$ 的初始值等于数组 $\text{nums}$ 的长度。

每次查找时，取 $\text{mid}$ 为 $\text{low}$ 和 $\text{high}$ 的平均数向下取整，判断是否存在长度为 $\text{mid}$ 且元素和大于等于 $\text{target}$ 的子数组，执行如下操作。

• 如果存在长度为 $\text{mid}$ 且元素和大于等于 $\text{target}$ 的子数组，则最小长度 $k$ 小于等于 $\text{mid}$，因此在 $[\text{low},\text{mid}]$ 中继续查找。

• 如果不存在长度为 $\text{mid}$ 且元素和大于等于 $\text{target}$ 的子数组，则最小长度 $k$ 大于 $\text{mid}$，因此在 $[\text{mid}+1,\text{high}]$ 中继续查找。

当 $\text{low}=\text{high}$ 时，查找结束，此时 $\text{low}$ 即为最小长度 $k$。

实现方面，由于只需要判断是否存在元素和大于等于 $\text{target}$ 的子数组，因此只要找到一个子数组的元素和大于等于 $\text{target}$ 即可提前返回。

代码

class Solution {public int minSubArrayLen(int target, int[] nums) {int total = Arrays.stream(nums).sum();if (total < target) {return 0;}int low = 1, high = nums.length;while (low < high) {int mid = low + (high - low) / 2;if (exists(target, nums, mid)) {high = mid;} else {low = mid + 1;}}return low;}public boolean exists(int target, int[] nums, int subarrayLen) {int sum = 0;int n = nums.length;for (int i = 0; i < subarrayLen; i++) {sum += nums[i];if (sum >= target) {return true;}}for (int i = subarrayLen; i < n; i++) {sum -= nums[i - subarrayLen];sum += nums[i];if (sum >= target) {return true;}}return false;}
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。当存在符合条件的子数组时，需要执行 $O(\log n)$ 次二分查找，每次二分查找需要 $O(n)$ 的时间遍历数组 $\text{nums}$，时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(1)$。