[209].长度最小的子数组

长度最小的子数组

• 题目
• 函数原型
• 边界判断
• 算法设计：枚举
• 算法设计：双指针

 

---

题目

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

示例:

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

 

---

函数原型

C 的函数原型：

int minSubArrayLen(int s, int* nums, int numsSize){}

 

---

边界判断

int minSubArrayLen(int s, int* nums, int numsSize){
	if( nums == NULL || numsSize == 0 )
		return NULL;
}

 

---

算法设计：枚举

这道题和《[53].最大子序和》类似，代码也差不多。

思路：把所有可能的子数组求和并更新 $ans$ ，直到我们找到最优子数组且和满足 $sum≥s$。

• 子数组的开始元素，可以是第 1 个到第 numsSize 个中的任意一个；
• 子数组的终止元素，只要不早于开始元素即可；
• 如果开始元素、开始元素能够确定，从开始元素到终止元素，做一次连加，就算出某个特定的开始元素到终止元素之间的元素和。

#define min(x, y) ((x)<(y)?(x):(y))

int minSubArrayLen(int s, int* nums, int numsSize){
	if( nums == NULL || numsSize == 0 )
		return 0;

	int ans = INT_MAX;
	for(int i=0; i<numsSize; i++)
		for(int j=i; j<numsSize; j++){
			int sum = 0;
			for(int k=i; k<=j; k++){
                sum += nums[k];
				if( sum >= s ){
					ans = min(ans, (j - i + 1));
					break;		// 找到最小位数的了，可以退出当前循环
                }
            }
        }

	return ans != INT_MAX ? ans : 0;
}

如果做面试题 $\Theta(n^{3})$，不太可能过关。

枚举求子数组的和需要的时间为 $\Theta(n)$，如果，从开始元素用一个累加器保存和，将累积和保存在一个数组里，就可以在 $\Theta(1)$

#define min(x, y) ((x)<(y)?(x):(y))

int minSubArrayLen(int s, int* nums, int numsSize){
	if( nums == NULL || numsSize == 0 )
		return 0;

	int ans = INT_MAX;
	int *sums = calloc( numsSize, sizeof(int) );
	
    sums[0] = nums[0];
    for(int i=1; i<numsSize; i++)
        sums[i] = sums[i-1] + nums[i];

    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            int sum = sums[j] - sums[i] + nums[i];
            if (sum >= s) {
                ans = min(ans, (j - i + 1));
                break; 		// 找到最小位数的了，可以退出当前循环
            }
        }
    }

    free(sums), sums = NULL;
	return ans != INT_MAX ? ans : 0;
}

枚举复杂度：

• 时间复杂度：$\Theta(n^{2})$
• 空间复杂度：$\Theta(1)$
   

---

算法设计：双指针

思路：找一个范围使得其值满足某个条件，然后就会想到滑动窗口，也就是用双指针的方法。和这道题本质是一样的。

• 用双指针 i 和 j 表示一个窗口
• 记录此时的长度，i 向右移动，开始减少长度，每减少一次，就更新最小长度
• 直到当前窗口内的数字和小于了 $s$，回到第 $1$

比如，现在看到这样一个子数组：

如果当前子数组的和，还不到 $s$，就往后多看一个数据。

把这个元素，纳入到 $nums$ 数组中。

如果还是没有到达 $s$，就继续往后看，不断纳入…直到 $sum >= s$，找到一个子数组。

而后，改变这个找到的子数组，让 i++，它的和就会少一些，不断的缩小…直到 $sum < s$。

此时，又可以向后看 即j++，$sum >= s$，找到一个子数组。

因为一直保持着一个窗口的样子，尽管长度不一，长度是由俩边的索引定义。这个窗口不停的向后滑动，来寻找满足条件的子数组，这种计算方法也被称为：“滑动窗口”。

#define min(x, y) ((x)<(y)?(x):(y))

int minSubArrayLen(int s, int* nums, int numsSize){
	if( nums == NULL || numsSize == 0 )
		return 0;

	int ans = INT_MAX;
    int sum = 0;

	// nums[i...j], 控制滑动窗口的双指针
	int i = 0;
	int j = -1;

	while( i < numsSize ){
		// 获取新窗口
		if( sum < s )
			sum += nums[++j];
		else
			sum -= nums[i++];
		
		if( sum >= s )
			ans = min(ans, (j - i + 1));
	}

	return ans != INT_MAX ? ans : 0;
}

但提交上去，发现数组越界访问了。

想一下，就知道是 右指针j 了，所以加个判断防止越界访问。

if( sum < s && j+1 < numsSize )

完整代码：

#define min(x, y) ((x)<(y)?(x):(y))

int minSubArrayLen(int s, int* nums, int numsSize){
	if( nums == NULL || numsSize == 0 )
		return 0;

	int ans = INT_MAX;
    int sum = 0;

	// nums[i...j], 控制滑动窗口的双指针
	int i = 0;
	int j = -1;

	while( i < numsSize ){
		// 获取新窗口
		if( sum < s && j+1 < numsSize )
			sum += nums[++j];
		else
			sum -= nums[i++];
		
		if( sum >= s )
			ans = min(ans, (j - i + 1));
	}

	return ans != INT_MAX ? ans : 0;
}

双指针复杂度：

• 时间复杂度：$\Theta(n)$
• 空间复杂度：$\Theta(1)$