zoukankan      html  css  js  c++  java
  • [LeetCode] Minimum Size Subarray Sum

    The problem statement has stated that there are both O(n) and O(nlogn) solutions to this problem. Let's see the O(n) solution first (taken from this link), which is pretty clever and short.

     1 class Solution {
     2 public:
     3     int minSubArrayLen(int s, vector<int>& nums) {
     4         int start = 0, sum = 0, minlen = INT_MAX;
     5         for (int i = 0; i < (int)nums.size(); i++) {
     6             sum += nums[i];
     7             while (sum >= s) {
     8                 minlen = min(minlen, i - start + 1);
     9                 sum -= nums[start++];
    10             }
    11         }
    12         return minlen == INT_MAX ? 0 : minlen;
    13     }
    14 };

    Well, you may wonder how can it be O(n) since it contains an inner while loop. Well, the key is that the while loop executes at most once for each starting position start. Then start is increased by 1 and the while loop moves to the next element. Thus the inner while loop runs at most O(n) times during the whole for loop from 0 to nums.size() - 1. Thus both the forloop and while loop has O(n) time complexity in total and the overall running time is O(n).

    There is another O(n) solution in this link, which is easier to understand and prove it is O(n). I have rewritten it below.

     1 class Solution {
     2 public:
     3     int minSubArrayLen(int s, vector<int>& nums) {
     4         int n = nums.size();
     5         int left = 0, right = 0, sum = 0, minlen = INT_MAX;
     6         while (right < n) {
     7             do sum += nums[right++];
     8             while (right < n && sum < s);
     9             while (left < right && sum - nums[left] >= s)
    10                 sum -= nums[left++];
    11             if (sum >= s) minlen = min(minlen, right - left);
    12         }
    13         return minlen == INT_MAX ? 0 : minlen;
    14     }
    15 };

    Now let's move on to the O(nlogn) solution. Well, this less efficient solution is far more difficult to come up with. The idea is to first maintain an array of accumulated summations of elements innums. Specifically, for nums = [2, 3, 1, 2, 4, 3] in the problem statement, sums = [0, 2, 5, 6, 8, 12, 15]. Then for each element in sums, if it is not less than s, we search for the first element that is greater than sums[i] - s (in fact, this is just what the upper_bound function does) in sumsusing binary search.

    Let's do an example. Suppose we reach 12 in sums, which is greater than s = 7. We then search for the first element in sums that is greater than sums[i] - s = 12 - 7 = 5 and we find 6. Then we know that the elements in nums that correspond to 6, 8, 12 sum to a number 12 - 5 = 7 which is not less than s = 7. Let's check for that: 6 in sums corresponds to 1 in nums8 insums corresponds to 2 in nums12 in sums corresponds to 4 in nums1, 2, 4 sum to 7, which is 12 in sums minus 5 in sums.

    We add a 0 in the first position of sums to account for cases like nums = [3], s = 3.

    The code is as follows.

     1 class Solution {
     2 public:
     3     int minSubArrayLen(int s, vector<int>& nums) {
     4         vector<int> sums = accumulate(nums);
     5         int minlen = INT_MAX;
     6         for (int i = 1; i <= nums.size(); i++) {
     7             if (sums[i] >= s) {
     8                 int p = upper_bound(sums, 0, i, sums[i] - s);
     9                 if (p != -1) minlen = min(minlen, i - p + 1);
    10             }
    11         }
    12         return minlen == INT_MAX ? 0 : minlen;
    13     }
    14 private:
    15     vector<int> accumulate(vector<int>& nums) {
    16         vector<int> sums(nums.size() + 1, 0);
    17         for (int i = 1; i <= nums.size(); i++)
    18             sums[i] = nums[i - 1] + sums[i - 1];
    19         return sums;
    20     }
    21     int upper_bound(vector<int>& sums, int left, int right, int target) {
    22         int l = left, r = right;
    23         while (l < r) {
    24             int m = l + ((r - l) >> 1);
    25             if (sums[m] <= target) l = m + 1;
    26             else r = m;
    27         }
    28         if (sums[r] > target) return r;
    29         if (sums[l] > target) return l;
    30         return -1;
    31     }
    32 };
  • 相关阅读:
    PC端微信扫码支付和支付宝跳转支付 斧头帮
    微信支付 斧头帮
    PC端实现浏览器点击分享到QQ好友,空间,微信,微博等 斧头帮
    图片,word,Excel等附件上传 斧头帮
    java定时任务详解 斧头帮
    手机浏览器实现分享给好友或是朋友圈 斧头帮
    Java缓存EhcacheEhcache的Cache在SSM框架中的配置 斧头帮
    通过精确地址获取经纬度 斧头帮
    SpringBoot中设置自定义拦截器 斧头帮
    Visual Studio 2008创建项目(ATL)
  • 原文地址:https://www.cnblogs.com/jcliBlogger/p/4600467.html
Copyright © 2011-2022 走看看