leetcode----前缀和数组问题（303、304、560题）

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])）

实例：

输入：
["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))

思路：前缀和

开辟一个额外的数组记录数组nums从0到当前索引对应元素的累加和，求数组从索引 i 到 j（i ≤ j）范围内元素的总和时，直接用j对应的累加和减去i-1位置的累加和即可。

class NumArray {

    private int[] preSum;

    public NumArray(int[] nums) {
        //preSum[0]=0 方便累加
        preSum = new int[nums.length + 1];
        for(int i = 1; i < preSum.length; i++){
            preSum[i] = preSum[i - 1] + nums[i - 1];
        }
    }
    
    public int sumRange(int left, int right) {
        //包含left与right   preSum[left] 对应left-1位置的累加和  right + 1对应 right位置的累加和
        return preSum[right + 1] - preSum[left];
    }
}

304.二维区域和检索-矩阵不可变

问题：给定一个二维矩阵 matrix，以下类型的多个请求：

• 计算其子矩形范围内元素的总和，该子矩阵的 左上角 为 (row1, col1) ，右下角 为 (row2, col2) 。

实现 NumMatrix 类：

• NumMatrix(int[][] matrix) 给定整数矩阵 matrix 进行初始化
• int sumRegion(int row1, int col1, int row2, int col2) 返回 左上角 (row1, col1) 、右下角 (row2, col2) 所描述的子矩阵的元素 总和 。

示例：

输入: 
["NumMatrix","sumRegion","sumRegion","sumRegion"]
[[[[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]],[2,1,4,3],[1,1,2,2],[1,2,2,4]]
输出: 
[null, 8, 11, 12]

解释:
NumMatrix numMatrix = new NumMatrix([[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]);
numMatrix.sumRegion(2, 1, 4, 3); // return 8 (红色矩形框的元素总和)
numMatrix.sumRegion(1, 1, 2, 2); // return 11 (绿色矩形框的元素总和)
numMatrix.sumRegion(1, 2, 2, 4); // return 12 (蓝色矩形框的元素总和)

思路：也是前缀和，使用一个二维数组preSum，记录当前位置到矩阵原点所组成矩形的元素的累加和。

如图，若要求红色矩阵内元素的累加和，则需要绿色矩阵 - 蓝色矩阵 - 棕色矩阵 + 粉色矩阵即可，另外求preSum数组的过程和这个过程类似，也是通过周围矩阵的运算得到的。代码如下：

class NumMatrix {

    private int[][] preSum;

    public NumMatrix(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        if(m == 0 || n == 0) {
            return;
        }
        preSum = new int[m + 1][n + 1];
        for(int i = 1; i <= m; i++){
            for(int j = 1; j <= n; j++){
                //
                preSum[i][j] = preSum[i - 1][j] + preSum[i][j - 1] + matrix[i - 1][j - 1] - preSum[i - 1][j  - 1]; 
            }
        }
    }
    
    public int sumRegion(int row1, int col1, int row2, int col2) {
        return preSum[row2 + 1][col2 + 1] - preSum[row1][col2 + 1] - preSum[row2 + 1][col1] + preSum[row1][col1];
    }
}

560.和为K的子数组

问题：给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的连续子数组的个数。

示例：

输入：nums = [1,1,1], k = 2
输出：2

输入：nums = [1,2,3], k = 3
输出：2

思路：

• 前缀和

计算出前缀和，然后枚举出每个子数组的和 统计子数组和等于k的情况。

class Solution {
    public int subarraySum(int[] nums, int k) {
        int len = nums.length;

        int[] preSum = new int[len + 1];
        for(int i = 1; i < preSum.length; i++){
            preSum[i] = preSum[i - 1] + nums[i - 1];
        }

        int res = 0;
        for(int i = 1; i <= len; i++){
            for(int j = 0; j < i; j++){
                // 子数组 nums[j..i-1] 的元素和
                if(preSum[i] - preSum[j] == k){
                    res++;
                }
            }
        }
        return res;
    }
}

• 哈希表+前缀和

只是使用前缀和 这个解法并不是最优的。这个嵌套for循环的内层循环就是在计算，有几个 j 能够使得 preSum[i] 和 preSum[j] 的差为 k，即存在几个j使得nums[0...i-1] - nums[0...j] = k，毎找到一个这样的 j，就把结果加一。我们将if的判断条件preSum[i] - preSum[j] == k移项，得到preSum[j] == preSum[i] - k。

所以优化的思路就是：直接记录有多少个preSum[j]和preSum[i] - k相等，然后更新结果。j <= i，所以preSum[j]的值可以直接计算出来，然后存起来，这样就可以去掉内层for循环了。可以用哈希表，在记录前缀和的同时记录该前缀和出现的次数。

class Solution {
    public int subarraySum(int[] nums, int k) {
        int len = nums.length;
        Map<Integer, Integer> preSum = new HashMap();
        preSum.put(0, 1);

        int sum0Toi = 0, sum0Toj = 0, res = 0;
        for(int i = 0; i < len; i++){
            sum0Toi += nums[i];
	   // 这是我们想找的前缀和 nums[0..j]
            sum0Toj = sum0Toi - k;
            int n;
            // 如果前面有这个前缀和，则直接更新答案
            if(preSum.containsKey(sum0Toj)){
                res += preSum.get(sum0Toj);
            }
            // 把前缀和 nums[0..i] 加入并记录出现次数
            preSum.put(sum0Toi, preSum.getOrDefault(sum0Toi, 0) + 1);
        }
        return res;
    }
}

整理思路，记录博客，以便复习。若有误，望指正~