【LeetCode】前缀和

接下来的时间里，Sivan带着大家一起学习数据结构与算法哟！

前缀和

下面几道题就是典型的前缀和问题，在读题目之前，要先了解这些知识：

• 什么是前缀和？
  就是将nums数组下标 0—i-1 的和（nums数组的前i个元素），放入preSum数组中，数组索引为i。
  一般，我们会让preSum[0]=0，表示nums数组的前0个元素的前缀和为0。

• 使用前缀和的好处？
  使用前缀和数组，可以轻松计算指定数组区间的和（数组不可变）。

LeetCode 303

这是一道典型的运用前缀和的题目。根据题目要求，计算一维数组left到right的和。

在了解了什么是前缀和之后，就可以写出此题的答案。先算出前缀和数组，之后将前缀和数组以一定规则相减则可以求出left-right的和。

代码实现：

class NumArray {
    private int [] preSum;
    public NumArray(int[] nums) {
    //preSum[0]默认为0，从1开始放入前缀和。
        preSum = new int [nums.length+1];
         //构建前缀和数组。
        for(int i=1;i<preSum.length;i++){
            preSum[i]=preSum[i-1]+nums[i-1];
        }
    }
    //利用preSum这个前缀和数组相减，获取left到right的和。
    public int sumRange(int left, int right) {
        return preSum[right+1]-preSum[left];
    }
}

LeetCode 304

这道题也可以利用前缀和解决，只不过从一维数组变成了二维数组。

• 怎样获取二维数组的前缀和数组？
  先构建一个二维数组，preSum[matrix.length+1][matrix[0].length+1]
  
  如图所示，将数组左上角的坐标默认为（0，0），并且所有矩阵以（0，0）为原点。让perSum[0][0]=0。

1. 如果想要获取[0,0,i,j]这个范围的前缀和，就是蓝色区域+黄色区域-粉色区域+红色区域。preSum[i][j]=preSum[i-1][j] + preSum[i][j-1] - preSum[i-1][j-1] + matrix[i-1][j-1];
2. 获取指定区域的二维数组也是类似的操作：
   比如，获取红区域的二维数组，用前缀和绿色区域-前缀和蓝色区域-前缀和黄色区域+前缀和粉色区域。preSum[row2+1][col2+1] - preSum[row2+1][col1] - preSum[row1][col2+1] + preSum[row1][col1]

代码实现：

class NumMatrix {
    private int [][] preSum;
    public NumMatrix(int[][] matrix) {
        int m=matrix.length;
        int n = matrix[0].length;
        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] - preSum[i-1][j-1] + matrix[i-1][j-1];
            }
        }
    }
    
    public int sumRegion(int row1, int col1, int row2, int col2) {
    //获取二维数组[row1,col1,row2,col2]区域的和。
        return preSum[row2+1][col2+1] - preSum[row2+1][col1] - preSum[row1][col2+1] + preSum[row1][col1];
    }
}

LeetCode 560

本题提供三种解题思路，思路由易到难。
注意，不可以使用滑动窗口，因为大小不确定，不知道向哪边滑动来寻找最小可行解

• 枚举法
  这是最简单的一种想法，我们当然不能满足于此。

class Solution {
    public int subarraySum(int[] nums, int k) {
        int ret=0;
        //使用双重for循环，得出所有的结果，每次sum改变就与k进行比较。
        for(int i=0;i<nums.length;i++){
            int sum=0;
            for(int j=i;j>=0;j--){
                sum+=nums[j];
                if(sum==k){
                    ret++;
                }
            }
        }
        return ret;
    }
}

• 前缀和
  构建前缀和数组，之后遍历前缀和数组相减寻找等于k的值。

class Solution {
    public int subarraySum(int[] nums, int k) {
        int n=nums.length;
        int [] preSum = new int [n+1];
        int ret=0;
        //构建前缀和数组。
        for(int i=1;i<=n;i++){
            preSum[i]=preSum[i-1]+nums[i-1];
        }
        //遍历前缀和数组，找到符合preSum[i]-preSum[j]==k的数。
        for(int i=0;i<=n;i++){
            for(int j=0;j<i;j++){
                if(preSum[i]-preSum[j]==k){
                    ret++;
                }
            }
        }
        return ret;
    }
}

• 前缀和+哈希表（较难）
  上述两个算法的时间复杂度还是O(n^2)，这里可以用HashMap来代替第二重for循环，从而让算法的效率达到最高。

class Solution {
    public int subarraySum(int[] nums, int k) {
        //维护一个哈希表，key表示前缀和，value表示前缀和的个数。
        HashMap <Integer,Integer> map = new HashMap<>();
        int sum0_i=0,ret=0;
        map.put(0,1);
        //只需要使用for循环。枚举所有的前缀和，找是否存在一种情况 sum0_i-k = sum0_j 满足此等式，如果满足这种情况，就让ret++。
        for(int i=0;i<nums.length;i++){
            sum0_i+=nums[i];
            
            int sum0_j=sum0_i-k;

            if(map.containsKey(sum0_ j)){
                ret+=map.get(sum0_ j);
            }
            
            //维护哈希表，放入每次计算的前缀和。
            map.put(sum0_i,map.getOrDefault(sum0_i,0)+1);
        }
        return ret;
    }
}

LeetCode 1

该题也是用哈希表的解法，可以给上一题用哈希表的方法进行参考。

哈希表思路：
最直接的想法是直接使用两层for循环，遍历数组，满足nums[i]+nums[j]=target就表示找到答案。
如果使用哈希表，就可以减少一层循环，把问题转化为给出所有的nums[i]，找出哈希表中满足target-nums[i]的key，即为答案。最后不要忘记维护哈希表。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //k:nums[i]，v：下标i
        HashMap <Integer,Integer> map = new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(target-nums[i])){
                return new int []{map.get(target-nums[i]),i};
            }
            map.put(nums[i],i);
        }
        return new int []{};
    }
}

---

⭐写在最后⭐
博主也是边学习边写作，如有异议敬请指出~
如果喜欢这篇文章的话，别忘了给博主点一个赞和关注⭐哟！
你的关注就是对我的最大鼓励！