leetcode: 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

进阶：

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

---

结果

• 使用快慢指针：滑动窗口
  

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        std::vector<int>::size_type sum = 0, res = 0;
        for (decltype(nums.size()) low = 0, fast = 0; fast < nums.size() && low <= fast;) {
            sum += nums[fast];
            if (sum < target) {
                ++fast;
                continue;
            }
            0 == res && (res = fast - low + 1);
            res = min(res, fast - low + 1);
            sum -= (nums[low] + nums[fast]);
            ++low;
        }
        return (int)res;
    }
};

• 时间复杂度：O(n)，其中 n是数组的长度。指针 low 和 fast最多各移动 n 次
• 空间复杂度：O(1)

---

时间复杂度优化

• 前缀和+二分查找
• 对于每个开始下标 i，可通过二分查找得到大于或等于 i 的最小下标 bound，使得 sums[bound]−sums[i−1]≥s，并更新子数组的最小长度（此时子数组的长度是 bound−(i−1)）

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int ans = INT_MAX;
        vector<int> sums(n + 1, 0); //长度为n+1的前缀和数组
        // 为了方便计算，令 size = n + 1 
        // sums[0] = 0 意味着前 0 个元素的前缀和为 0
        // sums[1] = A[0] 前 1 个元素的前缀和为 A[0]
        // 以此类推
        for (int i = 1; i <= n; i++) {
            sums[i] = sums[i - 1] + nums[i - 1];
        }
        for (int i = 1; i <= n; i++) {
            int target = s + sums[i - 1];
            auto bound = lower_bound(sums.begin(), sums.end(), target);
            if (bound != sums.end()) {
                ans = min(ans, static_cast<int>((bound - sums.begin()) - (i - 1)));
            }
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

• 时间复杂度：O(nlog⁡n)，其中 n 是数组的长度。需要遍历每个下标作为子数组的开始下标，遍历的时间复杂度是 O(n)，对于每个开始下标，需要通过二分查找得到长度最小的子数组，二分查找得时间复杂度是 O(log⁡n)，因此总时间复杂度是 O(nlog⁡n)。
• 空间复杂度：O(n)，其中 n 是数组的长度。额外创建数组 sums存储前缀和