209. Minimum Size Subarray Sum

source: LeetCode

Problem ID: 209

题意：

给定一个序列和一个正整数s，要求找出一个最短的子序列，它的各位之和大于等于正整数s，并返回这个子序列的长度。

解题思路：

要找出符合特定要求的一个子序列，可以将问题拆分。首先子序列的首位可以是给出的序列的任一位，因此可以用一个循环来遍历序列的每一位，接下来在循环的每一步中找出 以数组的某一位为首位的并且符合要求（即sum>s）的最短子序列，然后使用打擂台的方式找出符合要求的最短子序列。

代码：

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        bool find = 0;
    	int result = 0;
        for(int i = 0; i < nums.size(); i++){
        	int sum = 0;
        	for(int j = i; j < nums.size(); j++){
        		sum += nums[j];
        		if(sum >= s){
        			find = 1;
        			if(result)	result = min(result, j - i + 1);
        			else	result = j - i + 1;
        			break;
				}
			}
		}
		if(find)	return result;
		else	return 0;
    }
};

总结：

我的算法是比较暴力的求解，时间复杂度是O(n^2)，但是根据题目的提示可以知道是有O(n)和O(nlogn)的解法的。

O(n)的算法比较简洁：

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

O(nlogn)的算法要复杂一些：

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;
    }
};  

看到logn可以想到二分查找，但是给出的序列又不能排序。可以构造一个新的第i项为前i项和的序列，这个序列是递增的，就可以使用二分查找了。