209. Minimum Size Subarray Sum

题目：

Given an array of n positive integers and a positive integer s, find the minimal length of a subarray of which the sum ≥ s. If there isn't one, return
0 instead.

For example, given the array

[2,3,1,2,4,3]

and

s
= 7

,

the subarray

[4,3]

has the minimal length under the problem constraint.

click to show more practice.

More practice:
If you have figured out the O(n) solution, try coding another solution of which the time complexity is O(n logn).

题意：
给定一个包含n个元素的正整数数组和一个正整数s，找到一个长度最小，相加的和>=s的子数组。如果没有，返回0；

思路一：https://leetcode.com/discuss/42143/4ms-o-n-8ms-o-nlogn-c

轮训累加数组的每个元素，如果结果值大于s，则获取当前最小长度值，以及减去累加序列的第一个元素值使其小于s，外循环保证累加值大于s，小循环寻求最小长度值，以及使其累加值小于s。

代码：8ms 时间复杂度O(n)

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        
        int minimal = INT_MAX;
        int sum = 0, start = 0;
        
        if(nums.size()==0){
            return 0;
        }

        for(int i=0; i<nums.size(); i++){
            sum += nums[i];  //累加向前
            while(sum >= s){
                minimal = min(minimal, i-start+1);  //前项元素下标减去后项元素下标
                sum -= nums[start++];  //减去末尾元素
            }
        }
        
        return minimal == INT_MAX ? 0 : minimal;
    }
};

代码：4ms 时间复杂度O(n)

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

思路二：

使用额外的数组空间来保存每一个元素到其本身的累加值，如果累加值大于s，则用累加值减去s再去sums数组中利用二分查找进行查找。

代码：8ms 时间复杂度O(n logn)

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        
        vector<int> sums = accumulate(nums);
        int n = nums.size(), minlen = INT_MAX;
        for(int i=1; i<=n; i++){
            if(sums[i] >= s){
                int p = upper_bound(sums, 0, i, sums[i] - s);
                if(p != -1){
                    minlen = min(minlen, i - p + 1);
                }
            }
        }
        return minlen == INT_MAX ? 0 : minlen;
    }
    
private:
    vector<int> accumulate(vector<int>& nums){  //计算累加值数组
        int n = nums.size();
        vector<int> sums(n+1, 0);
        for(int i=1; i<=n; i++){
            sums[i] = nums[i-1] + sums[i-1];
        }
        return sums;
    }
    int upper_bound(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;
    }
};