Leetcode 303. 区域和检索 - 数组不可变

给定一个整数数组 nums，求出数组从索引 i 到 j（i ≤ j）范围内元素的总和，包含 i、j 两点。

实现 NumArray 类：

• NumArray(int[] nums) 使用数组 nums 初始化对象
• int sumRange(int i, int j) 返回数组 nums 从索引 i 到 j（i ≤ j）范围内元素的总和，包含 i、j两点（也就是 sum(nums[i], nums[i + 1], … , nums[j])）
  

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/range-sum-query-immutable
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * int param_1 = obj.sumRange(i,j);
 */

蛮力

class NumArray {
    int[] nums;
    public NumArray(int[] nums) {
        this.nums=nums;
    }
    
    public int sumRange(int i, int j) {
        int sum=0;
        for(int k=i;k<=j;k++)sum+=nums[k];
        return sum;
    }
}

public int sumRange(int i, int j)的时间复杂度为O(n)。

从题意来说，NumArray对象会被创建一次，但是求和会进行多次。也就是public NumArray(int[] nums)被调用一次，public int sumRange(int i, int j)被调用多次，所以应该尽可能地使public int sumRange(int i, int j)的资源消耗减少。所以针对这点可以进行一定的优化。

优化思路：在public NumArray(int[] nums)中直接算出结果并保存至二维数组，下面public NumArray(int[] nums)的时间复杂度为O(n³)，则最大执行次数为10¹²，过高。

class NumArray {
    int[][] sum;
    public NumArray(int[] nums) {
        int size= nums.length,sumij=0;
        int[][] sum = new int[size][size];
        for(int i=0;i<size;i++){
            for(int j=i;j<size;j++){
                for(int k=i;k<=j;k++){
                    sumij+=nums[k];
                }
                sum[i][j]=sumij;
                sumij=0;
            }
        }
        this.sum=sum;
    }
    public int sumRange(int i, int j) {
        return sum[i][j];
    }
}

对上面三层for优化，第三层可以简化，则下面public NumArray(int[] nums)的时间复杂度为O(n²)，则最大执行次数为10⁸，过高。

class NumArray {
    int[][] sum;
    public NumArray(int[] nums) {
        int size= nums.length,sumij=0;
        int[][] sum = new int[size][size];
        for(int i=0;i<size;i++){
            sum[i][i]=nums[i];
            for(int j=i+1;j<size;j++){
                sum[i][j]=sum[i][j-1]+nums[j];
            }
        }
        this.sum=sum;
    }
    public int sumRange(int i, int j) {
        return sum[i][j];
    }
}

前缀和

因为2层for执行次数依然较高，所以要考虑1层for。

实际上下面的并非真正的前缀和，但是和前缀和相似。preSum[i]存储nums[0]到nums[i]的值，包括两端，只需要nums.length个存储位置即可。那么数组 nums 从索引 i 到 j（i ≤ j）范围内元素的总和为preSum[j]-preSum[i-1]，不过public int sumRange(int i, int j)中需要对当i==0时进行判断防止越界。

class NumArray {
    int[] preSum;
    public NumArray(int[] nums) {
        int size= nums.length;
        for(int i=1;i<size;i++){
            nums[i]=nums[i-1]+nums[i];
        }
        preSum=nums;
    }
    public int sumRange(int i, int j) {
        return preSum[j]-(i==0?0:preSum[i-1]);
    }
}

真正的前缀和，因为上述public int sumRange(int i, int j)的一次判断多次调用也会影响效率，preSum[i]存储nums[0]到nums[i]的值，不包括右端的值，那么数组 nums 从索引 i 到 j（i ≤ j）范围内元素的总和为preSum[j+1]-preSum[i]，不过就是preSum的大小为nums.length+1。

class NumArray {
    int[] preSum;
    public NumArray(int[] nums) {
        int size= nums.length;
        int[] preSum = new int[size+1];
        preSum[0]=0;
        for(int i=1;i<size+1;i++){
            preSum[i]=preSum[i-1]+nums[i-1];
        }
        this.preSum=preSum;
    }
    public int sumRange(int i, int j) {
        return preSum[j+1]-preSum[i];
    }
}

优化到后面已经体现出了动态规划的思想。