【LeetCode】327. Count of Range Sum 区间和的个数（Hard）（JAVA）

【LeetCode】327. Count of Range Sum 区间和的个数（Hard）（JAVA）

题目地址: https://leetcode.com/problems/count-of-range-sum/

题目描述：

Given an integer array nums, return the number of range sums that lie in [lower, upper] inclusive.
Range sum S(i, j) is defined as the sum of the elements in nums between indices i and j (i ≤ j), inclusive.

Note:
A naive algorithm of O(n^2) is trivial. You MUST do better than that.

Example:

Input: nums = [-2,5,-1], lower = -2, upper = 2,
Output: 3 
Explanation: The three ranges are : [0,0], [2,2], [0,2] and their respective sums are: -2, -1, 2.

Constraints:

• 0 <= nums.length <= 10^4

题目大意

给定一个整数数组 nums，返回区间和在 [lower, upper] 之间的个数，包含 lower 和 upper。
区间和 S(i, j) 表示在 nums 中，位置从 i 到 j 的元素之和，包含 i 和 j (i ≤ j)。

说明:
最直观的算法复杂度是 O(n^2) ，请在此基础上优化你的算法。

解题方法

暴力遍历

1. 最直观的算法复杂度是 O(n^2) 的方法：用 sum[i] 表示前 i 个元素的和，然后遍历 j = [0, i]，判断 sum[i] - sum[j] 是否在 [lower, upper] 之间

class Solution {
    public int countRangeSum(int[] nums, int lower, int upper) {
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            long sum = 0;
            for (int j = i; j < nums.length; j++) {
                sum += nums[j];
                if (sum >= lower && sum <= upper) count++;
            }
        }
        return count;
    }
}

执行耗时:189 ms,击败了15.34% 的Java用户
内存消耗:38.2 MB,击败了94.66% 的Java用户

归并排序

1. 采用分治的思想进行优化，也就是归并排序： O(nlogn)
2. 把 sum 数组分为 sum[0, mid] 和 sum[mid + 1, n]，分别用 n1 和 n2 两个数组表示
3. 如果 n1 和 n2 两个数组都是有序递增的数组，很容易找出 n2[j] - n[i] 在 [lower, upper] 之间的个数
4. 所以我们就借用了归并排序
   • 把 sum 分为 sum[0, mid] = n1 和 sum[mid + 1, n] = n2
   • 对 n1 和 n2 进行归并排序（迭代方法）
   • 计算出 n2[j] - n1[i] 在 [lower, upper] 之间的个数
   • 最后加上 n1 和 n2 里面区间在 [lower, upper] 之间的个数
5. note: 1、和的 int 可能超限，需要用 long；2、对计算个数，可以用二分查找

class Solution {
    public int countRangeSum(int[] nums, int lower, int upper) {
        long[] sum = new long[nums.length + 1];
        long[] temp = new long[nums.length + 1];
        for (int i = 0; i < nums.length; i++) {
            sum[i + 1] = nums[i] + sum[i];
        }
        return sort(temp, sum, 0, sum.length - 1, lower, upper);
    }

    public int sort(long[] temp, long[] sum, int left, int right, int lower, int upper) {
        if (left >= right) return 0;
        int mid = left + (right - left) / 2;
        int res = 0;
        res += sort(temp, sum, left, mid, lower, upper);
        res += sort(temp, sum, mid + 1, right, lower, upper);
        for (int i = left; i <= mid; i++) {
            res += getRight(sum, sum[i] + upper, mid + 1, right) - getLeft(sum, sum[i] + lower, mid + 1, right) + 1;
        }
        int i = left;
        int j = mid + 1;
        while (i <= mid || j <= right) {
            int index = left + (i - left) + (j - mid - 1);
            if (i > mid) {
                temp[index] = sum[j];
                j++;
            } else if (j > right) {
                temp[index] = sum[i];
                i++;
            } else if (sum[i] > sum[j]) {
                temp[index] = sum[j];
                j++;
            } else {
                temp[index] = sum[i];
                i++;
            }
        }
        for (i = left; i <= right; i++) {
            sum[i] = temp[i];
        }
        return res;
    }

    public int getLeft(long[] sum, long num, int start, int end) {
        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (sum[mid] >= num) {
                end = mid - 1;
            } else {
                start = mid + 1;
            }
        }
        return end + 1;
    }

    public int getRight(long[] sum, long num, int start, int end) {
        while (start <= end) {
            int mid = start + (end - start) / 2;
            if (sum[mid] <= num) {
                start = mid + 1;
            } else {
                end = mid - 1;
            }
        }
        return start - 1;
    }
}

执行耗时:35 ms,击败了49.28% 的Java用户
内存消耗:39.2 MB,击败了10.04% 的Java用户

欢迎关注我的公众号，LeetCode 每日一题更新