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)) 时间复杂度的解法。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/minimum-size-subarray-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1. 窗口右边界右移增加总和，左边界右移减小总和，同时记录窗口大小

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        if target > sum(nums):
            return 0
        ln = len(nums)
        
        # 初始索引和窗口内总和
        i = 0
        j = 0
        sumN = 0
        # 初始化最小值为列表长度
        mi = ln
        # 遍历开始
        while j < ln:
            # j索引右边窗口边界
            sumN += nums[j]
            # 当前sumN比target大，左边窗口边界右移，同时计算最小值
            while sumN >= target:
                mi = min(mi,j-i+1)
                sumN -= nums[i]
                i+=1
            j+=1
        return mi

2. 窗口从小到大遍历列表（超时）

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        if target > sum(nums):
            return 0
        ln = len(nums)
        # 窗口大小
        ww = 1
        # 依次增大窗口
        while ww <= ln:
            for i in range(len(nums)-1,ww-2,-1):
                if target <= sum(nums[i-ww+1:i+1]):
                    return ww
            ww += 1
        return 0

3. 每次遍历更改窗口大小（超时）

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        if target > sum(nums):
            return 0
        ln = len(nums)
        
        # 从第一个元素开始索引
        i = 0
        # 初始化最小值
        mi = len(nums)
        # 遍历开始
        while i < ln:
            # [i:j+1]为窗口大小
            for j in range(i,ln):
                if sum(nums[i:j+1])>= target:
                    mi = min(j-i+1,mi)
                    break
            i+=1
        return mi

4. 窗口向右的过程中大小变化（超时）

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        if target > sum(nums):
            return 0
        ln = len(nums)
        
        # 从第一个元素开始索引
        i = 0
        j = i + 1
        # [i:j+1]为初始的满足条件的窗口大小
        while sum(nums[i:j]) < target:
            j+=1
        # 初始化最小值
        mi = len(nums[i:j])
        # 遍历开始
        while i < ln:
            while sum(nums[i:j]) < target and j <= ln:
                j+=1
            # print(nums[i:j])
            if sum(nums[i:j]) >= target:
                mi = min(mi,len(nums[i:j]))
            i+=1
        return mi

5. 初始化窗口，在遍历的时候调整大小（超时）

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        if target > sum(nums):
            return 0
        ln = len(nums)
        
        # 从第一个元素开始索引
        i = 0
        j = i + 1
        # [i:j+1]为初始的满足条件的窗口大小
        while sum(nums[i:j]) < target:
            j+=1
        # 初始化最小值
        mi = len(nums[i:j])
        # 遍历开始
        while i < ln:
            # 如果最大窗口右移后< target, 则继续右移
            while sum(nums[i:i+mi]) < target and i <= ln-mi:
                i+=1
            # 左移计数
            c = 1
            # 如果找到了，则尝试是否能够左移窗口左边边界
            while sum(nums[i+c:i+mi]) >= target and c<mi:
                c += 1
            mi-=c-1
            i+=1
        return mi