209. 长度最小的子数组 - 力扣（LeetCode）

题目描述

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组。如果不存在符合条件的连续子数组，返回 0。

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

进阶:
如果你已经完成了O(n) 时间复杂度的解法, 请尝试 O(n log n) 时间复杂度的解法。

题解1

暴力法，求出每个区间和然后判断是否不小于给定的s，然后满足条件的连续子数组的最小长度。这样直接暴力的时间复杂度为： $O(n^3)$。我们可以做适当的优化，先在 $O(n)$的时间可以计算出从起始位置到任意位置的连续和 $sums[i]$，则区间 $[i, j]$的和为 $sums[j] - sums[i - 1]$。利用空间将时间复杂度降为： $O(n^2)$。

代码1

/*
用sum[i]表示从0到下标i的连续和
[i, j]区间的连续和为sum[j] - sum[i - 1]
时间复杂度为：o(n^2) 超时
*/
class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int len = nums.size();
        vector<int>sum(len, 0);
        int res = 1 << 30;
        for(int i = 0; i < len; ++i){
            i == 0?sum[0] = nums[0]:sum[i]  = sum[i - 1] + nums[i];
        }
        for(int i = 0; i < len; ++i){
            for(int j = i; j < len; ++j){
                if(i == 0){
                    if(sum[j] >= s && j + 1 < res){
                        res = j + 1;
                        break;
                    }
                }
                else{
                    if(sum[j] - sum[i - 1] >= s && j - i + 1 < res){
                        res = j - i + 1;
                        break;
                    }
                }
            }
        }
        if(res == 1 << 30){
            res = 0;
        }
        return res;
    }
};

执行结果1

超时！！

题解2

因为同一位置开始的区间和是有序的（递增），可以用二分法找到刚好不小于给定s的区间可以将时间复杂度再次降为： $O(nlogn)$

代码2

/*
用sum[i]表示从0到下标i的连续和
[i, j]区间的连续和为sum[j] - sum[i - 1]
时间复杂度为：o(n^2) 超时
*/
class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int len = nums.size();
        vector<int>sum(len, 0);
        int res = 1 << 30;
        for(int i = 0; i < len; ++i){
            i == 0?sum[0] = nums[0]:sum[i]  = sum[i - 1] + nums[i];
        }
        for(int i = 0; i < len; ++i){
            int beg = i, end = len - 1, mid, tmp;
            while(beg <= end){//二分找满足条件的最小区间
                mid = (beg + end) >> 1;
                if(i == 0){
                    tmp = sum[mid];
                }
                else{
                    tmp = sum[mid] - sum[i - 1];
                }
                if(tmp >= s){
                    if(end - i + 1 < res){
                        res = mid - i + 1;
                    }
                    end = mid - 1;
                }
                else{
                    beg = mid + 1;
                }
            }
        }
        if(res == 1 << 30){
            res = 0;
        }
        return res;
    }
};

执行结果2

题解3

双指针法。
每个指针扫描范围最大是 $[0, len -1]$，时间复杂度为： $O(n)$。

代码3

/*
双指针法
双指针的范围都是从[0, len - 1]且只扫描一遍
时间复杂度为:O(n)
空间复杂度为:O(1)
*/
class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int len = nums.size();
        int res = 1 << 30, sum = 0, l = 0;//left指向左端点
        for(int r = 0; r < len; ++r){
            sum += nums[r];
            while(sum >= s){
                if(r - l + 1 < res){
                    res = r - l + 1;
                }
                sum -= nums[l++];
            }
        }
        return res == (1 << 30)?0:res;
    }
};

执行结果3