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 == ) return ;
         int i = ;
         int j = ;
         int tmpSum = ;
         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 + );
             i++, j++;
         }
         sz = ret.size();
         if(sz == ) return ;
         int min = ret[];
         for(int i = ; 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 = ,j = ;
         int currSum = ;
         int sz = nums.size();
         while(currSum < s && j < sz){
             currSum += nums[j++];
         }
         if(j == sz)
             return ;
         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;
     }
 };