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