LeetCode 209. Minimum Size Subarray Sum （最短子数组之和）

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.

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.

click to show more practice.

More practice:

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

---

题目标签：Array, Two Pointers, Binary Search

　　题目给了一个数组，和一个 s， 让我们找到一个 最短的连续子数组，它的数组之和大于等于 s。

　　题目说了两种方法：O(n) 和 O(n log n)

　　方法1： O(n) 利用 Two Pointers

　　设一个start 和一个 end，用sliding window， 一个窗口，start 到 end。

　　当 这个窗口的sum 小于 s 的时候，说明数字还不够大，需要更多数字，就延伸右边的 end 来得到更多数字；

　　当 这个窗口的sum 大于等于 s 的时候，说明 我们得到了一个 可能是答案的 window size，我们需要最小的。 然后把左边的start 向右延伸，继续寻找新的可能性。

　　

Java Solution:

Runtime beats 24.17%

完成日期：09/04/2017

关键词：Array，Two Pointers

关键点：Sliding window 控制左右边界，来找到最小的符合要求的 window size

 class Solution
 {
     public int minSubArrayLen(int s, int[] nums)
     {
         /* Solution 1: O(n)*/
         if(nums.length == 0)
             return 0;

         int start = 0;
         int end = 0;
         int res = Integer.MAX_VALUE;
         int sum = nums[start];

         while(true)
         {
             if(sum < s)
             {
                 // shift end to right one place
                 if(end + 1 == nums.length)
                     break;

                 sum += nums[++end];
             }
             else if(sum >= s)
             {
                 // get the smaller size
                 res = Math.min(res, end - start + 1);

                 if(end == start)
                     break;

                 // shift start to right one place
                 sum -= nums[start++];
             }
         }

         if(res == Integer.MAX_VALUE)
             res = 0;

         return res;
     }
 }

　　方法2：O(n log n) 利用 二分法来找到最小符合要求的 window size

　　要利用 binary search 的话，需要一个有序的数组，所以我们需要新设一个 原nums size + 1 的新 array sums， 把每一个从0 到 i （在nums中） 的sum 存入 新 array 的 index 1 到最后。

　　所以新的array 里， 从index 1 到最后的 每一个值 都是 原nums 相对应的 0 到 i 的sum。

　　原题例子：

　　nums 2 3 1 2 4 3　　　　原 array

　　sums 0 2 5 6 8 12 15　　新 array 第一个位置不用，后面每一个数字都是 nums 里相对应的sum值

　　在有了这个有序数组之后， 可以遍历新 array index 1 开始的每一个数字， 找到每一个最小的右边边界 (sums[i] + s) ，然后记录一个最小的window size 就可以了。

Java Solution:

Runtime beats 12.29%

完成日期：09/04/2017

关键词：Array，Binary Search

关键点：新建一个 ascending sums array 对应 nums array；

　　　　用二分法找到符合s要求的最小的window size

 class Solution
 {
     public int minSubArrayLen(int s, int[] nums)
     {
         int[] sums = new int[nums.length + 1];

         for (int i = 1; i < sums.length; i++)
             sums[i] = sums[i - 1] + nums[i - 1];

         int minLen = Integer.MAX_VALUE;

         for (int i = 0; i < sums.length; i++)
         {
             int end = binarySearch(i + 1, sums.length - 1, sums[i] + s, sums);

             if (end == sums.length)
                 break;

             if (end - i < minLen)
                 minLen = end - i;
         }
         return minLen == Integer.MAX_VALUE ? 0 : minLen;
     }

     public int binarySearch(int lo, int hi, int key, int[] sums)
     {
         while (lo <= hi)
         {
            int mid = (lo + hi) / 2;

            if (sums[mid] >= key)
                hi = mid - 1;
            else
                lo = mid + 1;

         }
         return lo;
     }
 }

参考资料：

https://discuss.leetcode.com/topic/13749/two-ac-solutions-in-java-with-time-complexity-of-n-and-nlogn-with-explanation

　　

LeetCode 算法题目列表 - LeetCode Algorithms Questions List