LeetCode303：区域和检索 - 数组不可变（暴力-缓存-动态规划）

LeetCode303：区域和检索 - 数组不可变（暴力-缓存-动态规划）

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

方法一：暴力求解：
1、每次调用 sumrange 时，我们都使用for循环将索引 i到 j之间的每个元素相加。
2、复杂度分析
时间复杂度：每次查询的时间 O(n)，每个 sumrange 查询需要 O(n) 时间。
空间复杂度：O(1)，请注意，nums 是对 nums 的引用，不是它的副本。

private int[] nums;

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

     /**
     * 给定一个整数数组  nums，求出数组从索引 i 到 j  (i ≤ j) 范围内元素的总和，包含 i,  j 两点。
     * 暴力求解
     * @param i
     * @param j
     * @return
     */
    public int sumRange(int i, int j) {
        if(j<i){
            return 0;
        }
        int sum = 0;
        for(int k=i;k<=j;k++){
            sum +=nums[k];
        }

        return sum;
    }

方法二：缓存：

复杂度分析：
空间复杂度：O(n)，
时间复杂度：每次查询的时间 O(1)，O(N) 预计算时间。由于累积和被缓存，每个sumrange查询都可以用 O(1) 时间计算。

//sum[k]定义为nums[0⋯k-1] 的累积和
private int[] sum;

public NumArray(int[] nums) {
    sum = new int[nums.length+1];

    for(int k =0;k<nums.length;k++){
        sum[k+1]=sum[k]+nums[k];
    }
}

    public int sumRange(int i, int j) {
        if(j<i){
            return 0;
        }

        return sum[j+1]-sum[i];
    }
}

方法三：动态规划：
1、动态规划的思想：存储中间值，定义一个二维数组用来存储nums[i…j]范围内元素的总和，调用的时候直接返回就好。
2、结果：超出内存限制 ，但也算求解的一种思路吧。
3、复杂度分析：
时间复杂度：O(N^)2
空间复杂度：O(N^2)

private int[][] dp;

public NumArray(int[] nums) {
    int len = nums.length;
    //定义状态:dp[i][j]表示从nums[i...j]内的元素的总和
    dp = new int[len][len];
     //状态初始化
        for(int index=0;index<len;index++){
            dp[index][index] = nums[index];
        }

        //状态转移方程：dp[i][j] = dp[i][j-1] + nums[j]
        for(int k=1;k<len;k++){
            for(int r=0;r<k;r++){
                dp[r][k] = dp[r][k-1]+nums[k];
            }
        }
}

    public int sumRange(int i, int j) {
        if(j<i){
            return 0;
        }
        return dp[i][j];
    }