给定一个整数数组 nums,处理以下类型的多个查询:
计算索引 left 和 right (包含 left 和 right)之间的 nums 元素的 和 ,其中 left <= right
实现 NumArray 类:
NumArray(int[] nums) 使用数组 nums 初始化对象
int sumRange(int i, int j) 返回数组 nums 中索引 left 和 right 之间的元素的 总和 ,包含 left 和 right 两点(也就是 nums[left] + nums[left + 1] + ... + nums[right] )
示例 1:
输入:
["NumArray", "sumRange", "sumRange", "sumRange"]
[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
输出:
[null, 1, -1, -3]
解释:
NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
numArray.sumRange(0, 2); // return 1 ((-2) + 0 + 3)
numArray.sumRange(2, 5); // return -1 (3 + (-5) + 2 + (-1))
numArray.sumRange(0, 5); // return -3 ((-2) + 0 + 3 + (-5) + 2 + (-1))
提示:
1 <= nums.length <= 104
-105 <= nums[i] <= 105
0 <= i <= j < nums.length
最多调用 104 次 sumRange 方法
方法一:前缀和
最朴素的想法是存储数组nums 的值,每次调用 sumRange 时,通过循环的方法计算数组 nums 从下标 i 到下标 j 范围内的元素和,需要计算 j−i+1 个元素的和。由于每次检索的时间和检索的下标范围有关,因此检索的时间复杂度较高,如果检索次数较多,则会超出时间限制。
由于会进行多次检索,即多次调用 sumRange,因此为了降低检索的总时间,应该降低 sumRange 的时间复杂度,最理想的情况是时间复杂度O(1)。为了将检索的时间复杂度降到 O(1),需要在初始化的时候进行预处理。
由此可知,要计算 sumRange(i,j),则需要计算数组 nums 在下标 j 和下标i−1 的前缀和,然后计算两个前缀和的差。
如果可以在初始化的时候计算出数组 nums 在每个下标处的前缀和,即可满足每次调用 sumRange 的时间复杂度都是O(1)。
具体实现方面,假设数组 nums 的长度为 n,创建长度为 n+1 的前缀和数组 sums,对于0≤i<n 都有 sums[i+1]=sums[i]+nums[i],则当 0<i≤n 时,sums[i] 表示数组nums 从下标 0 到下标 i−1 的前缀和。
将前缀和数组sums 的长度设为 n+1 的目的是为了方便计算sumRange(i,j),不需要对i=0 的情况特殊处理。此时有:
sumRange(i,j)=sums[j+1]−sums[i]
JAVA代码如下:
class NumArray {
int[] sums;
public NumArray(int[] nums) {
int n = nums.length;
sums = new int[n + 1];
for(int i = 0; i < n; i++){
sums[i + 1] = sums[i] + nums[i];
}
}
public int sumRange(int left, int right) {
return sums[right + 1] - sums[left];
}
}
GO代码如下:
type NumArray struct {
sums []int
}
func Constructor(nums []int) NumArray {
sums := make([]int, len(nums) + 1)
for i, v := range nums{
sums[i + 1] = sums[i] + v
}
return NumArray{sums}
}
func (this *NumArray) SumRange(left int, right int) int {
return this.sums[right + 1] - this.sums[left]
}