LeetCode 209. 长度最小的子数组(最小子列和) [难度：中等]

最新推荐文章于 2024-05-21 22:52:49 发布

鸿雁丨红豆灬

最新推荐文章于 2024-05-21 22:52:49 发布

阅读量225

点赞数

分类专栏：学习笔记之LeetCode 文章标签： leetcode

本文链接：https://blog.csdn.net/h465705089/article/details/125320635

版权

学习笔记之LeetCode 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

题目

给定一个含有 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
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题

暴力求解

int minSubArrayLen(int target, int* nums, int numsSize)
{
    int i,j,sum,len,MinSize = 100001;

    for(i=0;i<numsSize;i++){
        sum = 0;

        for(j=i;j<numsSize;j++){

            sum += nums[j];

            if(sum>=target){

                len = j-i+1;
                if(len < MinSize){
                    MinSize = len;
                }

                break;
            }
        } 
    }

    if(MinSize == 100001){
        MinSize = 0;
    }

    return MinSize;
}

时间复杂度O(N^2)；

滑动窗口（双指针法）

本题的最优解法：双指针start，end；初始化为数组第一下标即0；
end往后移位，确保start到end这个窗口的元素和sum >= target；
start往后移，寻找最小长度；

int minSubArrayLen(int target, int* nums, int numsSize)
{
    int start,end;
    start = end = 0;

    int sum = 0,MinSize = INT_MAX,len;

    while(end < numsSize){

        sum += nums[end];

        while(sum >= target){

            len = end-start+1;
            MinSize = len < MinSize ? len : MinSize;

            sum -= nums[start++];
        }

        end++;
    }

    return MinSize == INT_MAX ? 0 : MinSize;
}

时间复杂度O(N)；

进阶思路：前缀和+二分查找

这个思路刚开始有点绕，但是认真理解，一定大有裨益。

另申请一个前缀数组，即 sums[i] 表示原数组 nums 前 i 个元素之和；注意到本题所有的元素都是正整数，所以前缀和数组是有序的数组，这是二分查找的基础；

我们只需要找到 sums[k] - sums[j] >= s，那么 k-j 就是满足的连续子数组，但不一定是最小的，所以我们要继续找，直到找到最小的为止；

求 sums[k] - sums[j] >= s 我们可以求 sums[j] + s <= sums[k]，那这样就好办了，因为数组sums中的元素是递增的，也就是排序的，我们只需要求出 sum[j]+s 的值，然后使用二分法查找即可找到这个 k。

即对于数组sums的每一个j，查找这么一个k，使得 sums[k] >= sums[j] + s

int minSubArrayLen(int s, int *nums, int numsSize) 
{
	int sumsSize = numsSize+1;
	int* sums = malloc(sumsSize*sizeof(int));
	sums[0] = 0;
    
	int i;
	for(i=1;i<sumsSize;i++){
		sums[i] = sums[i-1] + nums[i-1];
	}
	
	int target,k,len,MinSize = INT_MAX;
	for(i=0;i<sumsSize;i++){
		target = sums[i]+s;
		
		k = BinarySearch( sums,i,sumsSize-1,target );
		if(k != -1){
			len = k-i;
			MinSize = len < MinSize ? len : MinSize;
		}

        if(MinSize == 1) break;
	}

	return MinSize == INT_MAX ? 0 : MinSize;
}

int BinarySearch( int* sums,int Left,int Right,int target )
{
    if(sums[Right] < target){
        return -1;
    }

	int Mid;
	while(Left < Right){
		Mid = Left + (Right - Left >> 1);

		if(sums[Mid] >= target){
			Right = Mid;
		}else{
			Left = Mid+1;
		}
	}
	
	return Left;
}