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