演算法之美：你可能想不到的歸併排序的神奇應用

韓子遲發表於2016-05-22

又是一道有意思的題目，Count of Range Sum。（PS：leetcode 我已經做了 190 道，歡迎圍觀全部題解 https://github.com/hanzichi/leetcode）

題意非常簡單，給一個陣列，如果該陣列的一個子陣列，元素之和大於等於給定的一個引數值（lower），小於等於一個給定的引數值（upper），那麼這為一組解，求總共有幾組解。

一個非常容易想到的解法是兩層 for 迴圈遍歷子陣列首尾，加起來判斷，時間複雜度 O(n^2)。

/**
 * @param {number[]} nums
 * @param {number} lower
 * @param {number} upper
 * @return {number}
 */
var countRangeSum = function(nums, lower, upper) {
  var len = nums.length;

  var ans = 0;

  for (var i = 0; i < len; i++) {
    var sum = 0;
    for (var j = i; j < len; j++) {
      sum += nums[j];
      if (sum >= lower && sum <= upper)
        ans++;
    }
  }

  return ans;
};

/**

* @param {number[]} nums

* @param {number} lower

* @param {number} upper

* @return {number}

var countRangeSum = function(nums, lower, upper) {

var len = nums.length;

var ans = 0;

for (var i = 0; i < len; i++) {

var sum = 0;

for (var j = i; j < len; j++) {

sum += nums[j];

if (sum >= lower && sum <= upper)

ans++;

}

return ans;

};

交了下 TLE 了，看了下測試資料，陣列長度為 9000，複雜度達到了 8100w，還是蠻大的。其實題目中也說了： A naive algorithm of O(n2) is trivial. You MUST do better than that.

如何將複雜度降到 log 級別？想到了二分的方法。可以將子陣列和轉換成兩個字首陣列和的差，定義陣列 sum, sum[i] 表示陣列前 i 個元素的和，特殊的, sum[0]=0，那麼元素 i 到元素 j 的和可以表示為 sum[j]-sum[i-1]。我們列舉 0 到 nums.length，比如列舉到了 sum[j]，我們需要求滿足條件的 i（i

解法似乎呼之而出，用二分維護有序陣列（用 splice 插入），同時用二分找到臨界的資料，一次迭代需要多次二分。二分查詢相關可以看我以前的文章二分查詢大集合（媽媽再也不用擔心我的二分查詢了）。

注意下二分的邊界，程式碼很容易寫出來。

function binarySearch1(a, target) {
  target += 1;
  var start = 0
    , end = a.length - 1;

  while(start <= end) {
    var mid = ~~((start + end) >> 1);
    if (a[mid] >= target)
      end = mid - 1;
    else 
      start = mid + 1;
  }

  return start;
}

function binarySearch2(a, target) {
  var start = 0
    , end = a.length - 1;

  while(start <= end) {
    var mid = ~~((start + end) >> 1);
    if (a[mid] >= target)
      end = mid - 1;
    else 
      start = mid + 1;
  }

  return end;
}


var countRangeSum = function(nums, lower, upper) {
  var len = nums.length;

  var sum = [];

  var ans = 0;

  var num = 0;

  sum.push(0);

  for (var i = 0; i < len; i++) {
    ans += nums[i];

    var a = ans - upper;
    var b = ans - lower;

    var pos1 = binarySearch2(sum, a) + 1;
    var pos2 = binarySearch1(sum, b) - 1;

    num += pos2 - pos1 + 1;

    var pos3 = binarySearch1(sum, ans);

    sum.splice(pos3, 0, ans);
  }
  
  return num;
  
};

function binarySearch1(a, target) {

target += 1;

var start = 0

, end = a.length - 1;

while(start <= end) {

var mid = ~~((start + end) >> 1);

if (a[mid] >= target)

end = mid - 1;

else

start = mid + 1;

}

return start;

}

function binarySearch2(a, target) {

var start = 0

, end = a.length - 1;

while(start <= end) {

var mid = ~~((start + end) >> 1);

if (a[mid] >= target)

end = mid - 1;

else

start = mid + 1;

}

return end;

}

var countRangeSum = function(nums, lower, upper) {

var len = nums.length;

var sum = [];

var ans = 0;

var num = 0;

sum.push(0);

for (var i = 0; i < len; i++) {

ans += nums[i];

var a = ans - upper;

var b = ans - lower;

var pos1 = binarySearch2(sum, a) + 1;

var pos2 = binarySearch1(sum, b) - 1;

num += pos2 - pos1 + 1;

var pos3 = binarySearch1(sum, ans);

sum.splice(pos3, 0, ans);

}

return num;

};

很不幸，還是 TLE 了，究其原因，我覺得應該是呼叫了 n 次 splice 方法。感覺維護一棵二叉搜尋樹應該是可行的，無奈不會手寫二叉搜尋樹 = =

那麼可行的解法是什麼呢？答案是歸併排序的 “另類使用”。這裡不講歸併排序，關於歸併排序，可見我以前的文章。

言歸正傳，首先預處理陣列的字首和，儲存到陣列 sum 中。然後用歸併排序對陣列 sum 進行排序，歸併排序中有一步呼叫 merge 函式，將有序的左陣列和右陣列進行合併，而這時的右陣列中的任一元素在 sum 陣列中的位置正是在左陣列任一元素之後！利用這，我們可以在 merge 前，對 left 陣列和 right 陣列滿足條件的元素進行求解。

這個函式我定義為 getAns：

/ 返回 b[j] - a[i] 值在 [wlower, wupper] 範圍內組數
function getAns(a, b) {

  var sum = 0;

  var lena = a.length; 
  var lenb = b.length;

  var start = 0;
  var end = 0;

  for (var i = 0; i < lenb; i++) {

    // to get start
    while (b[i] - a[start] >= wlower) {
      start++;
    }

    // to get end
    while (b[i] - a[end] > wupper) {
      end++;
    }

    sum += start - end;
  }

  return sum;

/ 返回 b[j] - a[i] 值在 [wlower, wupper] 範圍內組數

function getAns(a, b) {

var sum = 0;

var lena = a.length;

var lenb = b.length;

var start = 0;

var end = 0;

for (var i = 0; i < lenb; i++) {

// to get start

while (b[i] - a[start] >= wlower) {

start++;

}

// to get end

while (b[i] - a[end] > wupper) {

end++;

}

sum += start - end;

}

return sum;

做完一次歸併排序，每次 left 和 right 陣列合並前進行判斷，就將所有 sum[j]-sum[i]（j>i）的情況進行了判斷，簡直神奇！

完整程式碼參考我的 Github 。

224ms！Your runtime beats 100.00% of javascript submissions

還是有點小激動

打賞支援我寫出更多好文章，謝謝！
打賞作者

打賞支援我寫出更多好文章，謝謝！

演算法之美：你可能想不到的歸併排序的神奇應用

排序演算法之 '歸併排序'
2020-07-19
排序演算法
演算法之歸併排序
2019-03-14
演算法排序
排序演算法總結之歸併排序
2017-08-08
排序演算法
排序演算法之「歸併排序(Merge Sort)」
2021-02-17
排序演算法
排序演算法__歸併排序
2019-03-08
排序演算法
排序演算法:歸併排序
2018-07-18
排序演算法
歸併排序--排序演算法
2023-11-03
排序演算法
排序演算法 - 歸併排序
2018-03-11
排序演算法
排序演算法——歸併排序
2015-10-12
排序演算法
排序演算法(歸併排序)
2024-05-13
排序演算法
歸併排序詳解及應用
2022-02-28
排序
說說你對歸併排序的理解？如何實現？應用場景？
2024-04-24
排序
演算法之常見排序演算法-氣泡排序、歸併排序、快速排序
2019-10-21
演算法排序
排序演算法之歸併，快速，堆和桶
2019-03-02
排序演算法
演算法：排序連結串列：歸併排序
2020-11-21
演算法排序
演算法導論學習之六:歸併排序
2016-04-09
演算法排序
演算法學習 – 歸併排序
2019-03-03
演算法排序
演算法學習 - 歸併排序
2018-08-25
演算法排序
演算法與資料結構高階排序演算法之歸併排序
2019-03-03
演算法資料結構排序
[排序] 歸併排序
2017-12-05
排序
演算法（氣泡排序，快排，歸併排序）
2018-03-28
演算法排序
常見的排序演算法：冒泡、快排、歸併
2024-04-20
排序演算法
歸併排序
2024-03-09
排序
從演算法開始[歸併排序]
2021-01-18
演算法排序
快速排序&&歸併排序
2020-08-17
排序
【分治演算法】歸併排序，快速排序和漢諾塔
2017-09-13
演算法排序
深入理解 timsort 演算法（1）：自適應歸併排序
2016-04-18
演算法排序
從零開書學演算法（導論）之歸併排序
2017-10-24
演算法排序
演算法系列（四）排序演算法中篇--歸併排序和快速排序
2016-05-30
演算法排序
資料結構與演算法——排序演算法-歸併排序
2021-09-01
資料結構演算法排序
歸併排序的簡單理解
2022-06-24
排序
用“歸併”改進“快速排序” (轉)
2007-08-17
排序
歸併排序演算法(merge_Sort)
2021-02-17
排序演算法
四、歸併排序 && 快速排序
2020-06-05
排序
java歸併排序
2021-09-09
Java排序
[java]歸併排序
2017-08-27
Java排序
歸併排序模板
2012-09-11
排序
字元畫，你可能未知的美
2014-11-27
字元

演算法之美：你可能想不到的歸併排序的神奇應用

打賞支援我寫出更多好文章，謝謝！

相關文章