每日一题(LeetCode)----数组–长度最小的子数组

1.题目（ 209.长度最小的子数组）

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

输入：target = 4, nums = [1,4,4]
输出：1

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

2.解题思路

思路一： 暴力法

暴力法是最直观的方法。初始化子数组的最小长度为无穷大，枚举数组 nums 中的每个下标作为子数组的开始下标，对于每个开始下标 iii，需要找到大于或等于 iii 的最小下标 j，使得从 nums[i] 到 nums[j] 的元素和大于或等于 s，并更新子数组的最小长度（此时子数组的长度是 j−i+1j-i+1j−i+1）。

原作者：力扣官方题解

链接：https://leetcode.cn/problems/backspace-string-compare/

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

方法二的时间复杂度是 O(n2)，因为在确定每个子数组的开始下标后，找到长度最小的子数组需要 O(n) 的时间。如果使用二分查找，则可以将时间优化到 O(log⁡n)

为了使用二分查找，需要额外创建一个数组 sums 用于存储数组 nums 的前缀和，其中 sums[i]\text{sums}[i]sums[i] 表示从 nums[0] 到 nums[i−1]的元素和。得到前缀和之后，对于每个开始下标 iii，可通过二分查找得到大于或等于 iii 的最小下标 bound，使得 sums[bound]−sums[i−1]≥s，并更新子数组的最小长度（此时子数组的长度是 bound−(i−1)）。

因为这道题保证了数组中每个元素都为正，所以前缀和一定是递增的，这一点保证了二分的正确性。如果题目没有说明数组中每个元素都为正，这里就不能使用二分来查找这个位置了。

这里最开始没有看懂，看了力扣上这位网友的评论明白了很多

原作者：力扣官方题解

链接：https://leetcode.cn/problems/backspace-string-compare/

思路三： 滑动窗口

其实滑动窗口就是双指针，我们定义两个指针分别表示滑动窗口的起始位置和结束位置，滑动窗口就是子数组，以此我们就可以求出子数组的总和，看是否符合条件了

初始时滑动窗口的起始位置和结束位置都是数组的首元素，然后我们向右移动滑动窗口的结束位置，相当于是向右遍历一遍数组，每向右移动一位我们都看一下滑动窗口的总和是否大于等于目标值，如果大于我们就计算一下当前子数组长度，然后更新一下答案，之后让滑动窗口的起始位置向后移动一位，直到滑动窗口的总和下于目标值了，我们继续向右遍历，直到遍历结束，得到最终的答案

3.写出代码

思路一的代码：

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int ans = 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) {
                    ans = min(ans, j - i + 1);
                    break;
                }
            }
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

原作者：力扣官方题解

链接：https://leetcode.cn/problems/backspace-string-compare/

思路二的代码：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
       int length=nums.size();
       vector<int> sum(length+1,0);
       int ans=0x7fffffff;
       //得到前缀和
       for(int i=1;i<=length;i++){
           sum[i]=sum[i-1]+nums[i-1];
       }
       
       //遍历得到答案
       for(int i=1;i<=length;i++){
           int temp=target+sum[i-1];
           int bound=lower_bound(sum.begin(),sum.end(),temp)-sum.begin();
           //注意：lower_bound函数的返回值是第一个大于等于目标值的地址，所以我们这里减去首元素的地址就可以获得第一个大于等于目标值的下标了
            if(bound<length+1){
                ans=min(ans,bound-(i-1));
            }
       }
       if(ans==0x7fffffff){
           return 0;
       }
       else{
           return ans;
       }
    }
};

思路三的代码：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int length=nums.size();
        int i=0;
        int sum=0;
        int result=0x7fffffff;
        for(int j=0;j<length;j++){
            sum+=nums[j];
            while(sum>=target){
                result=min(result,j-i+1);
                sum-=nums[i];
                i++;
            }
        }
        if(result==0x7fffffff){
            return 0;
        }
        else{
            return result;
        }
    }
};