LeetCode-209. Minimum Size Subarray Sum

Description

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

Example

Input: [2,3,1,2,4,3], s = 7
Output: 2
Explanation: the subarray [4,3] has the minimal length under the problem constraint.

Follow up

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

Solution 1(C++)

class Solution {
public:
    int binSearch(vector<int>& nums, int target){
        int mid, left=0, right=nums.size()-1;
        while(left < right){
            mid = left + ((right-left+1)>>1);
            if(nums[mid] > target) right = mid-1;
            else left = mid;
        }
        return nums[left] <= target ? left : -1;
    }
    int minSubArrayLen(int s, vector<int>& nums) {
        vector<int> vec(1,0);
        int cur=0;
        int minlen=INT_MAX;
        for(int i=0; i<nums.size(); i++){
            cur += nums[i];
            int find=binSearch(vec, cur-s);
            if(find!=-1) minlen = min(minlen, i-find+1);
            vec.push_back(cur);
        }
        return minlen==INT_MAX ? 0 : minlen;
    }
};

Solution 2(C++)

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

Solution 3(C++)

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

算法分析

解法一是最先想出来的，类似的题目可以参考：

• LeetCode-560. Subarray Sum Equals K
• LeetCode-713. Subarray Product Less Than K
• LeetCode-795. Number of Subarrays with Bounded Maximum

只是在这基础之上，用二分查找加快了查找的速度。二分查找可以参考：

• Algorithm-Binary Search算法进阶理解
• Algorithm-Binary Search算法

而解法二与解法三均是O(n)时间，主要思路是：定义两个指针left和right，分别记录子数组的左右的边界位置，然后我们让right向右移，直到子数组和大于等于给定值或者right达到数组末尾，此时我们更新最短距离，并且将left像右移一位，然后再sum中减去移去的值，然后重复上面的步骤，直到right到达末尾，且left到达临界位置，即要么到达边界，要么再往右移动，和就会小于给定值。

与解法一的思路就是没有储存全部的0~i的子数组之和，而是将子数组的和动态维持在一定的范围之内，通过left与right。这是需要记住的。

程序分析

略。