LeetCode算法學習之--數組--區間和的個數

你們好今天給你們分享下一道 LeetCode 困難難度 的題目區間和的個數

這裏主要是分享思路和註釋，供你們更好的理解題目解法，代碼部分是參考LeetCode 轉寫成javascript 代碼，

題目

給你一個整數數組 nums 以及兩個整數 lower 和 upper 。求數組中，值位於範圍 [lower, upper] （包含 lower 和 upper）以內的 區間和的個數 。

區間和 S(i, j) 表示在 nums 中，位置從 i 到 j 的元素之和，包含 i 和 j (i ≤ j)。

輸入：nums = [-2,5,-1], lower = -2, upper = 2
輸出：3
解釋：存在三個區間：[0,0]、[2,2] 和 [0,2] ，對應的區間和分別是：-2 、-1 、2 。

複製代碼

分析

求區間S(i,j)，利用前綴的定義 S(i,j)===preSum(j)-preSum(i-1),

例如數組[1,2,3,4,5] 前綴preSum===[1,3,6,10,15],S(1,3)= preSum(3)-preSum(0)===10-1===9

因此題目等價於 lower<= preSum(j)-preSum(i-1)<=upper

那麼求區間的個數就是找個一共有多少個（j,i-1）屬於[lower,upper]

方法有多種，我這裏分享2種

1.歸併排序

2.二分查找

解法一： 歸併排序

代碼部分 轉載 leetcode-cn.com/problems/co…

思路

1.歸併排序的原理就是把一個數組拆分紅最小的單元，而後比較大小而後排序 而後再一層一層的組合起來，
這點很符合咱們的思路，咱們所須要的知足條件有2個
  1.i-1<j
  2.有序數列 (有序或者是無序對區間的個數是沒有影響的，由於總知足條件的區間的總個數是同樣的)
2.當找到了 遞歸中每一層中知足條件 j 和i-1, 採起 j-(i-1)的方式獲取知足條件的組的個數
3.最後把知足的個數累加起來





var countRangeSum = (nums, lower, upper) => {
  let sum = 0;
  // 由於須要永道 preSum(i-1),因此preSum的第一個值是0
  let preSum = [0];
  for (let i = 0; i < nums.length; i++) {
    sum += nums[i];
    preSum.push(sum);
  }

  return countRangeSumRecursive(preSum, lower, upper, 0, preSum.length - 1);
};

function countRangeSumRecursive(preSum, lower, upper, left, right) {
  // 遞歸的終止條件 也就是當i-1===j的時候，不知足題目的條件因此返回0
  if (left === right) {
    return 0;
  }

  const mid = Math.floor((left + right) / 2);
  // preSum[left] - preSum[mid] 中知足條件的個數
  const n1 = countRangeSumRecursive(preSum, lower, upper, left, mid);
  // preSum[mid+1] - preSum[right] 中知足條件的個數
  const n2 = countRangeSumRecursive(preSum, lower, upper, mid + 1, right);
  // res 記錄累加起來的個數
  let res = n1 + n2;

  // 求解知足條件的個數
  let i = left,
    l = mid + 1,
    r = mid + 1;
  /* 先肯定一個 i 知足條件的個數，在移動i求知足條件的個數， 當i>mid的時候終止，這裏的i 表明的歸併中左邊的有序數組， l和r表示右邊的有序數組 */

  while (i <= mid) {
    while (l <= right && preSum[l] - preSum[i] < lower) l++;
    while (r <= right && preSum[r] - preSum[i] <= upper) r++;
    // 求裏面知足條件的區間的個數
    res += r - l;
    i++;
  }

  // 合併有序數組
  let sorted = [];
  let p = 0;
  let p1 = left;
  let p2 = mid + 1;

  while (p1 <= mid || p2 <= right) {
    if (p1 > mid) {
      sorted[p++] = preSum[p2++];
    } else if (p2 > right) {
      sorted[p++] = preSum[p1++];
    } else {
      if (preSum[p1] <= preSum[p2]) {
        sorted[p++] = preSum[p1++];
      } else {
        sorted[p++] = preSum[p2++];
      }
    }
  }

  // 更新preSum 爲有序數列
  for (let i = 0; i < sorted.length; i++) {
    preSum[left + i] = sorted[i];
  }

  return res;
}
/* 複雜度 時間 O(nLogn) 空間 O(n) */
複製代碼

解法二：二分查找

代碼部分 轉載 leetcode-cn.com/problems/co…

思路
1.lower<=preSum(j)-preSum(i-1)<=upper => preSum(j)-upper<=pre(i-1)<=preSum(j)-lower，
2.由於j>=i 因此能夠理解爲在j以前的前綴和 存在 preSum(j)-upper<=pre(i-1)<=preSum(j)-lower 則知足區間條件
3.這裏米涉及了 二分查找 中的 尋找最左索引的 bisect_left 和最右索引的bisect_right (我後面會分享，這裏就不細講了)
*/



// 尋找最左索引值
function bisect_left(nums, target) {
  let l = 0,
    r = nums.length - 1;

  while (l <= r) {
    const mid = Math.floor(l + (r - l) / 2);
    if (nums[mid] >= target) {
      r = mid - 1;
    } else {
      l = mid + 1;
    }
  }

  return l;
}

// 尋找最右索引值
function bisect_right(nums, target) {
  let l = 0,
    r = nums.length - 1;

  while (l <= r) {
    const mid = Math.floor(l + (r - l) / 2);
    if (nums[mid] <= target) {
      l = mid + 1;
    } else {
      r = mid - 1;
    }
  }

  return l;
}

var countRangeSum = (nums, lower, upper) => {
  let sum = 0;
  // 由於須要永道 preSum(i-1),因此preSum的第一個值是0
  let preSum = [0];
  let res = 0;

  // 遍歷nums的每個值
  for (const num of nums) {
    sum += num;

    // 求知足區間的個數, 這個時候 sum至關於 preSum(j), 這個時候的preSum至關於preSum(i-1)
    const n1 = bisect_right(preSum, sum - lower);
    const n2 = bisect_left(preSum, sum - upper);
    res += n1 - n2;

    preSum.push(sum);
    // 排序
    preSum.sort((a, b) => a - b);
  }

  return res;
};

/* 複雜度 時間 O(nLogn) 空間 O(n) */


複製代碼

總結

這道題 比較難，須要的前置知識比較多， 「前綴和」 「二分查找」 「歸併排序」須要你們掌握才能理解

你們能夠看看我分享的一個專欄（前端搞算法）裏面有更多關於算法的題目的分享，但願可以幫到你們，我會盡可能保持天天晚上更新，若是喜歡的麻煩幫我點個贊，十分感謝

文章內容目的在於學習討論與分享學習算法過程當中的心得體會，文中部分素材來源網絡，若有侵權，請聯繫刪除，郵箱 182450609@qq.com