[Leetcode]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.

class Solution {
public:
    /*algorithm：brute force
        time O(n*n) space O(1)
    */
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        int len = n+1;
        for(int i = 0;i < n;i++){
            int sum = nums[i];
            for(int j = i;j < n;j++){
                if((j-i+1) >= len)break;
                if(j > i)sum += nums[j];
                if(sum >= s && (j-i+1) < len){
                    len = j-i+1;
                }
                
            }
        }
        return len == (n+1)?0:len;
    }
};

class Solution {
public:
    /*algorithm: two pointer
        1)two pointer l,r ,subarray[l..r]
        2)first find subarray [l,r] which sum >=s
        3)slide window to look for other subarry which meet sum >=s 
        time O(n) space O(1)
    */
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        int i = 0,j = 0;
        int sum = 0;
        int minLen = INT_MAX;
        //find first subarray sum >= s //[2,3,1,2,4,3], 7 
        while(i < n && j < n){
            while(sum < s && j < n) sum += nums[j++];
            //slide sub-array window to find other subarray which sum >=s 
            while(sum >=s && i < j) {
                minLen = min(minLen,j-i);
                sum -= nums[i++];
            }
            
        }
        return minLen == INT_MAX?0:minLen;
    }
};

class Solution {
public:
    /*algorithm: binary search
        1)setup one array each element is sum(0,i-1),named ss[0,n+1];
        2)binary search ss, for each ss[i],search one ss[j] which >= ss[i]+s
        time O(nlogn) space O(n)
        */
        //[l,r]   s[l] < val && s[r] >= val
    int bsearch(vector<int>&s,int l,int r,int val){
        int mid;
        while(r-l > 0){
            mid = l + (r-l)/2;
            if(s[mid] < val)l = mid + 1;
            else r = mid;
        }
        return s[l] >= val?l:-1;
    }
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        int len = INT_MAX;
        vector<int>sum(n+1,0);
        for(int i = 1;i < n+1;i++)
            sum[i] = sum[i-1]+nums[i-1];
        if(sum[n] < s)return 0;
        for(int i = 0;i < n+1;i++){
            int j = bsearch(sum,i,n,sum[i] + s);
            if(j > 0)len = min(len,j-i);
        }
        return len == INT_MAX?0:len;
    }
};

class Solution {
public:
    /*algorithm: binary search
        1)setup one array each element is sum(0,i-1),named ss[0,n+1];
        2)binary search ss, for each ss[i],search one ss[j] which >= ss[i]+s
        time O(nlogn) space O(1)
        */
        //[l,r]   s[l] < val && s[r] >= val
    int bsearch(vector<int>&s,int l,int r,int val){
        int mid;
        while(r-l > 0){
            mid = l + (r-l)/2;
            if(s[mid] < val)l = mid + 1;
            else r = mid;
        }
        return s[l] >= val?l:-1;
    }
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        int len;
        for(int i = 1;i < n;i++)
            nums[i] = nums[i-1]+nums[i];
        if(n < 1 || nums[n-1] < s)return 0;
        len = bsearch(nums,0,n-1,s) + 1;
        for(int i = 0;i < n;i++){
            int j = bsearch(nums,i,n-1,nums[i] + s);
            if(j >= 0)len = min(len,j-i);
        }
        return len;
    }
};