【数组基础】Leetcode 209.长度最小的子数组

209.长度最小的子数组

解题思路

        第一个想法是在输入的时候顺便求一个前缀和，这样求任意区间的和的复杂度为O(n^2)，由于答案在线性区间 [1,n] 中，还可以用二分法省去一些重复查找。这个方法比不做任何处理就遍历相加当然要好，但是这样的优化还不够，况且核心代码模式由于不需要手动输入，需要花费额外时间计算前缀和。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums)
    {
        int n = nums.size();

        int sum[n];
        memset(sum, 0, sizeof(sum));
        sum[0] = nums[0];
        for (int i = 1; i < n; i++)
            sum[i] = nums[i]+sum[i-1];

        if(sum[n-1] < target)
            return 0;

        int l = 1;
        int r = n;
        for (; l <= r; )
        {
            int mid = (l + r) >> 1;
            for(int j = mid; j < n; j++)
            {
                if(sum[j] - sum[j-mid] >= target)
                    r = mid-1;
            }
            if(r > mid)
                l = mid+1;
        }
        return l;
    }
};

后来就想到这道题跟前几天做的10012. 「一本通 1.2 例 2」Best Cow Fences 非常像，其中为了求区间最大和采用了这样的处理：

long long former = 0;           
for(int i = l; i <= n; i++)  //保证子列长度大于l
{
	former = min(former, b[i-l]);  //前i-l项的最小子列前缀和
	long long temp = b[i]-former;  //前i项最大子列前缀和
}

在以上的代码里面，子列的首项是可以自由移动的。按照之前的遍历相加方法，需要两层循环，外层遍历首项位置，内层遍历末项位置，时间复杂度为O(n^2)，如果运用滑动窗口，同时调整首项末项位置，只需要单层循环，时间复杂度为O(n)。

for(int i = 0; i < n ; i++)
{
	sum += nums[i];
	while(sum >= target)
	{
		cont = min(cont, i+1-l);
		sum -= nums[l];
		l++;
	}
}

核心代码

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums)
    {
        int n = nums.size();

        int cont = n+1;
        int l = 0;
        int sum = 0;
        for(int i = 0; i < n ; i++)
        {
            sum += nums[i];
            while(sum >= target)
            {
                cont = min(cont, i+1-l);
                sum -= nums[l];
                l++;
            }
        }
        if(cont == n+1)
            return 0;
        else
            return cont;
    }
};