【LeetCode-209】Minimum Size Subarray Sum(C++)

题目要求：给出一个数组nums和一个正整数s，求nums的子数组中和大于s的长度最小的子数组的长度。

问题解答：

1.用两个指针，left和right，从left位置开始的和大于s的子数组的长度。然后把这个长度存起来，left++。在找到以left位置开始的和大于s的子数组的长度，和之前存起来的长度相比较，取最小值。一直到right指向最后一个位置的后一个位置，且sum<s，说明从left位置开始到最后都没有和大于s的子数组了。停止循环，输出最小长度。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int l=nums.size();
        int left=0,right=0;
        int result=INT_MAX;
        int sum=0;
        while(right<=l){
            while(right<l&&sum<s){
                sum+=nums[right];
                right++;
            }
            if(right<=l&&sum>=s){
                result=result<right-left?result:right-left;
                sum=sum-nums[left];
                left++;
            }
            if(right==l&&sum<s)
                break;
        }
        if(result==INT_MAX)
            result=0;
        return result;
        
    }
};

翻了一下leetcode评论区的答案，发现别人跟我一样的思路，但是写出来的代码要简洁好多，本来我还不知道我的代码的时间复杂度是多少，但是看了这个代码之后发现时间复杂度是O(n)。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n=nums.size();
        int left=0;
        int result=INT_MAX;
        int sum=0;
        for(int i=0;i<n;i++){
            sum+=nums[i];
            while(sum>=s){
                result=result>i-left+1?i-left+1:result;
                sum-=nums[left++];
            }
        }
        if(result==INT_MAX)
            result=0;
        return result;
    }
};

因为对于每一个left值，while循环只做一次。直到left增大到n或者for循环结束，所以在for循环的整个过程中，while循环最多做了n次。for循环也是做了n次，所以总的算下来时间复杂度为O（n）。

2.时间复杂度为O(nlogn)的解法，首先根据数组nums获得数组sums，其中数组sums保存了nums中从0到i的元素的和。具体解决方法看代码注释。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int l=nums.size();
        vector<int> sums;
        int result=INT_MAX;
        int value=0;
        for(int i=0;i<l;i++){
            value+=nums[i];
            sums.push_back(value);
        }//获取数组sums
        for(int i=0;i<l;i++){
            if(sums[i]>=s){
                int p=upper(sums,0,i,sums[i]-s);
                if(p!=-1){
                    result=result>(i-p+1)?(i-p+1):result;
                }
            }
        }//从数组sums中找到大于s的数，然后找到第一个大于sums[i]-s的数的位置p，则i-p+1就是以元素nums[i]结尾的和大于s的子数组的元素个数。找出所有的子数组，取最小值。
        return result==INT_MAX?0:result;
    }
private:
    int upper(vector<int>& sums,int left,int right,int target){
        int l=left,r=right;
        while(l<r){
            int m=l+((r-l)>>1);
            if(sums[m]<=target) 
                l=m+1;
            else
                r=m;
        }
        return (sums[r]>target)?r:-1;
    }//用二分查找法找出sums中从索引left到right中第一个大于target的数，由于是二分查找，故时间复杂度为O(logn)，所以整个算法的时间复杂度为O(nlogn)。
};