LeetCode-303. Range Sum Query - Immutable

本来真的是超简单一道题，但是数据量一大却变得不好处理。这道题也让我明白了在数据量不同的情况下完成相同的任务是完全不同的难度。

---

303.

Range Sum Query - Immutable

Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.

Example:
Given nums = [-2, 0, 3, -5, 2, -1]

sumRange(0, 2) -> 1
sumRange(2, 5) -> -1
sumRange(0, 5) -> -3
Note:
1.You may assume that the array does not change.
2.There are many calls to sumRange function.

一开始觉得很简单的一道题啊，然后几分钟就写好了。

public 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;
    }
}

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

看过我博客的或者刷过题的应该都知道test case是什么尿性，所以前面的测试都通过了，最后来了个很大的数组，直接TLE。
好吧，这个方法时间复杂度是o（N），这都通不过看来只能想想用常数级别时间复杂度的方法了。

想了个办法，在构造函数里加一个数组，这个数组的长度和输入的数组一样，假设输入的数组是nums，新加的数组是arr，然后：

arr[i]= nums[0]+nums[1]+…+nums[i-1]+nums[i]

很难用语言描述，反正新数组对应的位置放的数字是输入数组从0到对应位置的和
然后计算一个区间的和的时候，例如要i-j之间的，那么就先获得0-j的和（就是arr[j]），再获得0-i的和（就是arr[i]），然后0-j的和减去0-i的和就是i-j之间的和了
上代码

public class NumArray {

    int [] nums;
    int [] arr;
    public NumArray(int[] nums) {
        this.nums=nums;
        arr=getArr();
    }

    public int sumRange(int i, int j) {

        if(i==0){
            return arr[j];
        }else{
            return sumRange(0,j)-sumRange(0,i-1);
        }
    }

    private int[] getArr(){

        int[] arr=new int[nums.length];

        for(int i=0;i<nums.length;i++){

            if(i==0){
                arr[i]=nums[i];
            }else{
                arr[i]=nums[i]+arr[i-1];
            }

        }

        return arr;
    }


}

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

值得注意的是，因为这道题的sumRange函数会被多次调用，所以获得新数组的操作不可以在sumRange函数做，否则就会重复获得新数组的动作导致TLE（别问我为什么知道的），因此我把它放入构造函数并作为成员变量使用。