leetcode 209. 长度最小的子数组

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

解题分析：

方法一：暴力解法

利用两个 for 循环，开始枚举数组， i 作为开始下标，j 作为终值下标，使得从 nums[i] 到 nums[j] 的和大于或等于 s，并更新子数组的最小长度。
时间复杂度：O(n^2)。

public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        int res = INT_MAX;
        for (int i = 0; i < n; i++) {
            int sum = 0;
            for (int j = i; j < n; j++) {
                sum += nums[j];
                if (sum >= s) {
               // 子数组和超过了s，更新res
                    res = min(res, j - i + 1);
                    break;//符合条件就break
                }
            }
        }
        return res == INT_MAX ? 0 : ans;
    }
};

方法二：滑动窗口

采取滑动窗口的方法，即根据它们的和的值来不断调整子数组的起始位置和终止位置，从而动态的改变滑动窗口的大小，最后找出最小的连续数组。滑动窗口其实是双指针的一种，首先固定住左指针，移动右指针，记录它们的和，直至其大于等于 target ；然后移动左指针，收缩窗口，直到和小于 target 再移动右指针，并更新区间。

时间复杂度：O(n)。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int res = INT_MAX;
        int sum = 0;
        for(int i = 0, j = 0; i < nums.size(); i++)
        {
            sum += nums[i];     //向右扩展窗口
            while(sum - nums[j] >= target) sum -= nums[j++]; //收缩窗口
            if(sum >= target)  res = min(res, i - j + 1);    //区间更新
        }
        return res == INT_MAX ? 0 : res;	
    }
};

方法三：前缀和+二分法

使用前缀和和二分法，首先需要额外创建一个数组 sum 用于存储数组 nums 的前缀和，其中 sum[i] 表示从 nums[0] 到 nums[i−1] 的元素和。得到前缀和之后，下标 i 作为起始位置，利用二分法使得 sum[mid+1]−sum[i] ≥ s，并更新子数组的最小长度。

时间复杂度： O(nlogn)。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size();
        //数组sum 用于存储数组 nums 的前缀和，其中sum[i] 表示从nums[0] 到 nums[i−1] 的元素和。
        vector<int> sum(n + 1, 0);//定义了一个大小为n+1的数组，都赋值为0
        for (int i = 0; i < n; i ++)
            sum[i+1] = sum[i] + nums[i];
        
        int res = INT_MAX;
        //二分
        for (int i = 0; i < n; i ++)
        {
            int l = 0;
            int r = n;
            while (l < r)
            {
                int mid = (l + r) / 2;
                if (sum[mid + 1] - sum[i] >= target)
                    r = mid;
                else
                    l = mid + 1;
            }
            if (r < n)
                res = min(res, r - i + 1);
        }

        return res == INT_MAX ? 0 : res;

    }
};