排序题目：区间和的个数

题目

标题和出处

标题：区间和的个数

出处：327. 区间和的个数

难度

8 级

题目描述

要求

给定一个整数数组 $\text{nums}$ 以及两个整数 $\text{lower}$ 和 $\text{upper}$，返回数组中的值位于范围 $\text{[lower, upper]}$（包含 $\text{lower}$ 和 $\text{upper}$）内的区间和的个数。

区间和 $\text{S(i, j)}$ 表示 $\text{nums}$ 从下标 $\text{i}$ 到 $\text{j}$ 的元素之和（包含 $\text{i}$ 和 $\text{j}$，$\text{i}\le \text{j}$）。

示例

示例 1：

输入：$\text{nums = [-2,5,-1], lower = -2, upper = 2}$
输出：$\text{3}$
解释：三个区间是 $\text{[0,0]}$、$\text{[2,2]}$ 和 $\text{[0,2]}$，对应的区间和分别是 $\text{-2}$、$\text{-1}$、$\text{2}$。

示例 2：

输入：$\text{nums = [0], lower = 0, upper = 0}$
输出：$\text{1}$

数据范围

• $\text{1}\le \text{nums.length}\le {\text{10}}^{\text{5}}$
• ${\text{-2}}^{\text{31}}\le \text{nums[i]}\le {\text{2}}^{\text{31}}-\text{1}$
• ${\text{-10}}^{\text{5}}\le \text{lower}\le \text{upper}\le {\text{10}}^{\text{5}}$
• 保证答案是一个 $\text{32}$ 位的整数

解法一

预备知识

这道题的解法涉及到前缀和。对于长度为 $n$ 的数组 $\text{nums}$ 计算前缀和，需要创建长度为 $n+1$ 的数组 $\text{sums}$，对于 $1\le i\le n$ 有 $\text{sums}[i]={\sum }_{k=0}^{i-1}\text{nums}[k]$，即 $\text{sums}[i]$ 表示数组 $\text{nums}$ 的前 $i$ 个元素之和，$\text{sums}[0]=0$。

对于 $0\le i<n$，$\text{sums}[i+1]-\text{sums}[i]=\text{nums}[i]$，因此 $\text{sums}[i+1]=\text{sums}[i]+\text{nums}[i]$，对于 $\text{sums}$ 中的每个元素都可以在 $O(1)$ 的时间内计算得到，整个数组 $\text{sums}$ 的计算时间是 $O(n)$。

得到前缀和数组 $\text{sums}$ 之后，原数组 $\text{nums}$ 的任何子数组的和都可以在 $O(1)$ 的时间内计算得到。对于 $\text{nums}$ 的下标范围 $[j,k]$ 的子数组，其中 $0\le j\le k<n$，该子数组的和为 $\text{sums}[k+1]-\text{sums}[j]$。

思路和算法

对于长度为 $n$ 的数组，不同的区间个数是 $\frac{n(n+1)}{2}$。如果直接计算每个区间的区间和，则时间复杂度至少是 $O(n^2)$。由于数组 $\text{nums}$ 的长度最大为 $10^5$，因此 $O(n^2)$ 的时间复杂度过高，必须使用时间复杂度更低的方法。

首先计算数组 $\text{nums}$ 的前缀和数组 $\text{sums}$，然后根据 $\text{sums}$ 计算原数组的区间和。对于 $0\le \text{start}\le \text{end}\le n$，考虑数组 $\text{nums}$ 的下标范围 $[\text{start},\text{end}-1]$ 的区间，该区间的长度是 $\text{end}-\text{start}$，区间和是 $\text{sums}[\text{end}]-\text{sums}[\text{start}]$。

当 $\text{start}\ge \text{end}$ 时，区间的长度是 $0$，此时不存在区间和位于范围 $[\text{lower},\text{upper}]$ 内。当 $\text{start}<\text{end}$ 时，区间的长度大于等于 $1$，将 $\text{sums}$ 的下标范围 $[\text{start},\text{end}]$ 的子数组分成两个更短的子数组，对两个更短的子数组内的前缀和排序之后合并，同时计算范围 $[\text{lower},\text{upper}]$ 内的区间和的个数（以下简称「区间和的个数」）。具体做法如下。

1. 取 $\text{start}$ 和 $\text{end}$ 的平均值 $\text{mid}$，将 $\text{sums}$ 的下标范围 $[\text{start},\text{end}]$ 的子数组分成下标范围 $[\text{start},\text{mid}]$ 和下标范围 $[\text{mid}+1,\text{end}]$ 的两个子数组。

2. 对两个子数组分别排序并计算区间和的个数，得到两个升序的子数组和两个子数组分别包含的区间和的个数。

3. 计算两个升序子数组之间的区间和的个数。定义指针 $i$ 在左边的升序子数组中从左到右移动，即 $i$ 在范围 $[\text{start},\text{mid}]$ 中从左到右移动，对于每个 $i$，需要在右边的升序子数组中找到相应的区间 $[\text{left},\text{right})$，使得对于任何 $\text{left}\le j<\text{right}$，都有 $i<j$ 且 $\text{lower}\le \text{sums}[j]-\text{sums}[i]\le \text{upper}$，则以 $i$ 为区间开始位置的区间和的个数是 $\text{right}-\text{left}$。

4. 计算两个升序子数组之间的区间和的个数之后，合并两个升序子数组。

当整个数组排序结束时即可得到整个数组的区间和个数。

计算两个升序子数组之间的区间和的个数的过程中，当 $i$ 增加时，对应的 $\text{left}$ 和 $\text{right}$ 也一定增加，因此 $i$、$\text{left}$ 和 $\text{right}$ 都是按照从小到大的顺序变化。计算两个升序子数组之间的区间和的个数与合并两个升序子数组的时间复杂度相同，计算区间和的个数并没有提升总时间复杂度，总时间复杂度和原始归并排序一样是 $O(n\log n)$。

归并排序可以使用自顶向下的方式递归实现，也可以使用自底向上的方式迭代实现。对于同一个数组，使用自顶向下和自底向上两种方式实现的中间过程可能有所区别，但是都能得到正确的结果。

代码

以下代码为归并排序的自顶向下实现。

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

    public int mergeSortAndCount(long[] sums, int lower, int upper, int start, int end) {
        if (start >= end) {
            return 0;
        }
        int mid = start + (end - start) / 2;
        int count = mergeSortAndCount(sums, lower, upper, start, mid) + mergeSortAndCount(sums, lower, upper, mid + 1, end);
        int left = mid + 1, right = mid + 1;
        for (int i = start; i <= mid; i++) {
            while (left <= end && sums[left] - sums[i] < lower) {
                left++;
            }
            while (right <= end && sums[right] - sums[i] <= upper) {
                right++;
            }
            count += right - left;
        }
        merge(sums, start, mid, end);
        return count;
    }

    public void merge(long[] sums, int start, int mid, int end) {
        int currLength = end - start + 1;
        long[] temp = new long[currLength];
        int i = start, j = mid + 1, k = 0;
        while (i <= mid && j <= end) {
            if (sums[i] <= sums[j]) {
                temp[k++] = sums[i++];
            } else {
                temp[k++] = sums[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = sums[i++];
        }
        while (j <= end) {
            temp[k++] = sums[j++];
        }
        System.arraycopy(temp, 0, sums, start, currLength);
    }
}

以下代码为归并排序的自底向上实现。

class Solution {
    public int countRangeSum(int[] nums, int lower, int upper) {
        int count = 0;
        int length = nums.length;
        long[] sums = new long[length + 1];
        for (int i = 0; i < length; i++) {
            sums[i + 1] = sums[i] + nums[i];
        }
        int sumLength = sums.length;
        for (int halfLength = 1, currLength = 2; halfLength < sumLength; halfLength *= 2, currLength *= 2) {
            for (int start = 0; start < sumLength - halfLength; start += currLength) {
                int mid = start + halfLength - 1;
                int end = Math.min(start + currLength - 1, sumLength - 1);
                int left = mid + 1, right = mid + 1;
                for (int i = start; i <= mid; i++) {
                    while (left <= end && sums[left] - sums[i] < lower) {
                        left++;
                    }
                    while (right <= end && sums[right] - sums[i] <= upper) {
                        right++;
                    }
                    count += right - left;
                }
                merge(sums, start, mid, end);
            }
        }
        return count;
    }

    public void merge(long[] sums, int start, int mid, int end) {
        int currLength = end - start + 1;
        long[] temp = new long[currLength];
        int i = start, j = mid + 1, k = 0;
        while (i <= mid && j <= end) {
            if (sums[i] <= sums[j]) {
                temp[k++] = sums[i++];
            } else {
                temp[k++] = sums[j++];
            }
        }
        while (i <= mid) {
            temp[k++] = sums[i++];
        }
        while (j <= end) {
            temp[k++] = sums[j++];
        }
        System.arraycopy(temp, 0, sums, start, currLength);
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。计算前缀和需要 $O(n)$ 的时间，归并排序需要 $O(n\log n)$ 的时间，时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。前缀和需要 $O(n)$ 的空间，自顶向下实现时需要递归调用栈的空间是 $O(\log n)$，自底向上实现时可以省略递归调用栈的空间，无论是自顶向下实现还是自底向上实现，归并过程需要 $O(n)$ 的辅助空间。

解法二

预备知识

该解法涉及到前缀和与线段树。

前缀和为数组的前缀子数组的元素和，数组的每个下标对应一个前缀和，根据前缀和可以快速得到任意一个子数组的元素和。

线段树是一种二叉搜索树，将一个区间划分成两个更短的区间。线段树中的每个叶结点都是长度为 $1$ 的区间，称为单元区间。

线段树支持区间的快速查询和修改。对于长度为 $n$ 的区间，使用线段树查询特定子区间的元素个数以及修改特定子区间内的元素个数的时间是 $O(\log n)$。

有时，为了降低线段树的空间复杂度，需要使用离散化。

思路和算法

为了计算区间和的个数，可以首先计算原数组的前缀和数组。对于前缀和 $\text{sum}$，如果存在一个下标更小的前缀和 ${\text{sum}}^{\prime }$ 满足 $\text{lower}\le \text{sum}-{\text{sum}}^{\prime }\le \text{upper}$，则原数组中存在一个区间和为 $\text{sum}-{\text{sum}}^{\prime }$，该区间和在范围 $[\text{lower},\text{upper}]$ 中。

由于 $\text{lower}\le \text{sum}-{\text{sum}}^{\prime }\le \text{upper}$ 等价于 $\text{sum}-\text{upper}\le {\text{sum}}^{\prime }\le \text{sum}-\text{lower}$，因此对于前缀和 $\text{sum}$，需要计算下标更小的前缀和中有多少个前缀和在范围 $[\text{sum}-\text{upper},\text{sum}-\text{lower}]$ 中，得到区间和的个数。

由于前缀和的取值范围很大，因此需要使用离散化限定范围。使用哈希集合存储所有可能的前缀和，对于前缀和 $\text{sum}$，将 $\text{sum}$、$\text{sum}-\text{upper}$ 和 $\text{sum}-\text{lower}$ 添加到哈希集合中。然后使用列表存储哈希集合中的所有元素，将列表升序排序，并记录每个元素在列表中的名次，即每个元素在列表中的下标。

创建线段树，用于存储列表中的每个元素的名次。从左到右遍历前缀和数组，对于每个前缀和 $\text{sum}$，其左边的前缀和已经遍历过，对于其左边的前缀和 ${\text{sum}}^{\prime }$，存在一个区间和 $\text{sum}-{\text{sum}}^{\prime }$，如果 $\text{sum}-\text{upper}\le {\text{sum}}^{\prime }\le \text{sum}-\text{lower}$，则区间和 $\text{sum}-{\text{sum}}^{\prime }$ 在范围 $[\text{lower},\text{upper}]$ 中。得到 $\text{sum}$ 的名次 $\text{rank}$，以及 $\text{sum}-\text{upper}$ 和 $\text{sum}-\text{lower}$ 的名次 $\text{start}$ 和 $\text{end}$，计算线段树的子区间 $[\text{start},\text{end}]$ 中的元素个数，该元素个数即为已经遍历过的在范围 $[\text{sum}-\text{upper},\text{sum}-\text{lower}]$ 中的前缀和个数，将区间和的个数增加该前缀和个数。更新区间和的个数之后，将 $\text{rank}$ 添加到线段树中，继续遍历后面的前缀和并更新区间和的个数。遍历结束之后，即可得到在范围 $[\text{lower},\text{upper}]$ 中的区间和的个数。

代码

class Solution {
    public int countRangeSum(int[] nums, int lower, int upper) {
        int count = 0;
        int length = nums.length;
        long[] sums = new long[length + 1];
        for (int i = 0; i < length; i++) {
            sums[i + 1] = sums[i] + nums[i];
        }
        Set<Long> set = new HashSet<Long>();
        for (int i = 0; i <= length; i++) {
            long sum = sums[i];
            set.add(sum);
            set.add(sum - upper);
            set.add(sum - lower);
        }
        List<Long> sumsList = new ArrayList<Long>(set);
        Collections.sort(sumsList);
        Map<Long, Integer> ranks = new HashMap<Long, Integer>();
        int size = sumsList.size();
        for (int i = 0; i < size; i++) {
            ranks.put(sumsList.get(i), i);
        }
        SegmentTree st = new SegmentTree(size);
        for (int i = 0; i <= length; i++) {
            long sum = sums[i];
            int rank = ranks.get(sum);
            long minSum = sum - upper, maxSum = sum - lower;
            int start = ranks.get(minSum), end = ranks.get(maxSum);
            count += st.getCount(start, end);
            st.add(rank);
        }
        return count;
    }
}

class SegmentTree {
    int length;
    int[] tree;

    public SegmentTree(int length) {
        this.length = length;
        this.tree = new int[length * 4];
    }

    public int getCount(int start, int end) {
        return getCount(start, end, 0, 0, length - 1);
    }

    public void add(int rank) {
        add(rank, 0, 0, length - 1);
    }

    private int getCount(int rangeStart, int rangeEnd, int index, int treeStart, int treeEnd) {
        if (rangeStart > rangeEnd) {
            return 0;
        }
        if (rangeStart == treeStart && rangeEnd == treeEnd) {
            return tree[index];
        }
        int mid = treeStart + (treeEnd - treeStart) / 2;
        if (rangeEnd <= mid) {
            return getCount(rangeStart, rangeEnd, index * 2 + 1, treeStart, mid);
        } else if (rangeStart > mid) {
            return getCount(rangeStart, rangeEnd, index * 2 + 2, mid + 1, treeEnd);
        } else {
            return getCount(rangeStart, mid, index * 2 + 1, treeStart, mid) + getCount(mid + 1, rangeEnd, index * 2 + 2, mid + 1, treeEnd);
        }
    }

    private void add(int rank, int index, int start, int end) {
        if (start == end) {
            tree[index]++;
            return;
        }
        int mid = start + (end - start) / 2;
        if (rank <= mid) {
            add(rank, index * 2 + 1, start, mid);
        } else {
            add(rank, index * 2 + 2, mid + 1, end);
        }
        tree[index] = tree[index * 2 + 1] + tree[index * 2 + 2];
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。可能的前缀和个数是 $O(n)$，每个前缀和在线段树中的查询和更新操作都需要 $O(\log n)$ 的时间，时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。创建前缀和数组、前缀和列表与线段树需要 $O(n)$ 的空间。

解法三

预备知识

该解法涉及到树状数组。

前缀和为数组的前缀子数组的元素和，数组的每个下标对应一个前缀和，根据前缀和可以快速得到任意一个子数组的元素和。

树状数组也称二叉索引树，由 Peter M. Fenwick 发明，因此又称 Fenwick 树。树状数组支持快速计算数组的前缀和与区间和，以及快速修改。对于长度为 $n$ 的区间，使用树状数组查询特定子区间的区间和以及修改特定子区间内的元素值的时间是 $O(\log n)$。

有时，为了降低树状数组的空间复杂度，需要使用离散化。

思路和算法

计算区间和的个数也可以使用树状数组实现。

首先计算原数组的前缀和数组并将所有前缀和离散化，然后创建树状数组，用于存储每个可能的前缀和的名次。从左到右遍历前缀和数组，对于每个前缀和 $\text{sum}$，得到 $\text{sum}$ 的名次 $\text{rank}$，以及 $\text{sum}-\text{upper}$ 和 $\text{sum}-\text{lower}$ 的名次 $\text{start}$ 和 $\text{end}$，计算树状数组的子区间 $[\text{start},\text{end}]$ 中的元素个数，该元素个数即为已经遍历过的在范围 $[\text{sum}-\text{upper},\text{sum}-\text{lower}]$ 中的前缀和个数，将区间和的个数增加该前缀和个数。更新区间和的个数之后，将 $\text{rank}$ 添加到树状数组中，继续遍历后面的前缀和并更新区间和的个数。遍历结束之后，即可得到在范围 $[\text{lower},\text{upper}]$ 中的区间和的个数。

代码

class Solution {
    public int countRangeSum(int[] nums, int lower, int upper) {
        int count = 0;
        int length = nums.length;
        long[] sums = new long[length + 1];
        for (int i = 0; i < length; i++) {
            sums[i + 1] = sums[i] + nums[i];
        }
        Set<Long> set = new HashSet<Long>();
        for (int i = 0; i <= length; i++) {
            long sum = sums[i];
            set.add(sum);
            set.add(sum - upper);
            set.add(sum - lower);
        }
        List<Long> sumsList = new ArrayList<Long>(set);
        Collections.sort(sumsList);
        Map<Long, Integer> ranks = new HashMap<Long, Integer>();
        int size = sumsList.size();
        for (int i = 0; i < size; i++) {
            ranks.put(sumsList.get(i), i);
        }
        BinaryIndexedTree bit = new BinaryIndexedTree(size);
        for (int i = 0; i <= length; i++) {
            long sum = sums[i];
            int rank = ranks.get(sum);
            long minSum = sum - upper, maxSum = sum - lower;
            int start = ranks.get(minSum), end = ranks.get(maxSum);
            count += bit.getCount(start, end);
            bit.add(rank);
        }
        return count;
    }
}

class BinaryIndexedTree {
    int length;
    int[] tree;

    public BinaryIndexedTree(int length) {
        this.length = length;
        this.tree = new int[length + 1];
    }

    public int getCount(int start, int end) {
        return getPrefixSum(end + 1) - getPrefixSum(start);
    }

    public void add(int index) {
        index++;
        while (index <= length) {
            tree[index]++;
            index += lowbit(index);
        }
    }

    private int getPrefixSum(int index) {
        int sum = 0;
        while (index > 0) {
            sum += tree[index];
            index -= lowbit(index);
        }
        return sum;
    }

    private static int lowbit(int x) {
        return x & (-x);
    }
}

复杂度分析

• 时间复杂度：$O(n\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。可能的前缀和个数是 $O(n)$，每个前缀和在树状数组中的查询和更新操作都需要 $O(\log n)$ 的时间，时间复杂度是 $O(n\log n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。创建前缀和数组、前缀和列表与树状数组需要 $O(n)$ 的空间。