LeetCode OJ：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.

给一个数组以及一个数字，求满足大于该数字的最小的连续的数组元素个数的最小值。

代码写的比较乱。具体的思想就是用两个指针，一个先向前走， 当相加之和大于s的时候，将另一个指针也向前走，并减去相应的数字，当小于的时候将元素的个数存入数组，代码如下：

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int sz = nums.size();
        vector<int> ret;
        if(sz == 0) return 0;
        int i = 0;
        int j = 0;
        int tmpSum = 0;
        while(j < sz){
            for( ; i < sz; ++i){
                tmpSum += nums[i];
                if(tmpSum >= s)
                    break;
            }
            if(tmpSum < s) break;　//i已经达到数组的末尾了
            for( ; j <= i; ++j){
                tmpSum -= nums[j];
                if(tmpSum < s)
                    break;
            }
            ret.push_back(i - j + 1);
            i++, j++;
        }
        sz = ret.size();
        if(sz == 0) return 0;
        int min = ret[0];
        for(int i = 1; i < sz; ++i){
            if(min > ret[i])
                min = ret[i];
        }
        return min;
    }
};

 java版本代码如下所示，对上面做了一些改进，其实完全用不到上下两个循环的，双指针一次搞定：

public class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        if(nums.length == 0)
            return 0;
        int subSum = nums[0];
        int ret = Integer.MAX_VALUE;
        int p1 = 1, p2 = 0;
        while(p2 < p1){
            if(subSum < s){　　//达不到k，指针前移动或者移动到头直接返回
                if(p1 < nums.length){
                    subSum += nums[p1];
                    p1++;
                }else{
                    if(ret == Integer.MAX_VALUE)
                        return 0;
                    return ret;
                }
            }else{　　　　　　//达到k，后指针向前移动并且考虑是否更新指针。
                ret = Math.min(ret, p1-p2);
                subSum -= nums[p2];
                p2++;
            }
        }
        if(ret == Integer.MAX_VALUE) //如果没有找到合适的子数组的话，直接返回0
            return 0;
        return ret;
    }
}

新修改的方法为：

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int min = INT_MAX;
        int i = 0,j = 0;
        int currSum = 0;
        int sz = nums.size();
        while(currSum < s && j < sz){
            currSum += nums[j++];
        }
        if(j == sz)
            return 0;
        while(j != sz && i <= j){
            if(currSum >= s)
                min = min(min, currSum);
            while(i < j && currSum >= s){
                currSum -= nums[i++];
            }
            while(j != sz && currSum < s){
                currSum += nums[++j];
            }
        }
        return min;
    }
};