[Java 算法] 前缀和（2）

练习 一 : 除自身外数组的乘积

238. 除了自身以外数组的乘积 - 力扣（LeetCode）

class Solution {

public int[] productExceptSelf(int[] nums) {
    int len = nums.length;
    int[] pre = new int[len];
    int[] last = new int[len];
    int[] ret = new int[len];
    pre[0] = 1;
    last[len-1] = 1;
    for(int i = 1;i<len;i++){
        pre[i] = pre[i-1]*nums[i-1];
    }

    for(int i = len-2;i>=0;i--){
        last[i] = last[i+1]*nums[i+1];
    }

    for(int i = 0;i<len;i++){
    ret[i] = last[i]*pre[i];
    }

    return ret;

}

}

前缀积 : prei 表示 , 下标 i 左侧所有元素的乘积(不包含 numsi)

后缀积 : lasti 表示 , 下标 i 右侧所有元素的乘积(不包含 numsi)

除当前下标外所有元素乘积 : reti = prei*lasti

练习二 : 和为 K 的子数组

560. 和为 K 的子数组 - 力扣（LeetCode）

解法一 : 暴力枚举

class Solution {
public int subarraySum(int[] nums, int k) {
    int len = nums.length;
    int count = 0;
    for(int i = 0;i<len;i++){
        int sum = 0;
        for(int j = i;j<len;j++){
            sum+=nums[j];
            if(sum == k){
                count++;
            }
        }
        }

    return count;
    }
}

两层循环枚举了所有的情况 ,

sum 累加 numsj : 动态计算 numsi 到 numsj 的和 , 不重不漏

解法二 :

前缀和+哈希表

class Solution {
    public int subarraySum(int[] nums, int k) {
        // 哈希表：key=前缀和，value=该前缀和出现的次数（用于快速查询）
        Map<Integer,Integer> hash = new HashMap<>();
        int len = nums.length;
        int sum = 0,ret = 0; // sum：动态维护的前缀和；ret：符合条件的子数组数量
        // 初始化：前缀和为0的情况出现1次（对应preSum[0]=0，处理从下标0开始的子数组）
        hash.put(0,1);
        for(int i = 0;i<len;i++){
            sum += nums[i]; // 计算当前前缀和（前i+1个元素的和）
            // 核心：查询是否存在「前缀和 = sum - k」，存在则累加其出现次数
            // 原理：sum(当前) - sum(历史) = k → 这两个前缀和之间的子数组和为k
            ret += hash.getOrDefault(sum - k, 0);
            // 记录当前前缀和的出现次数（已存在则+1，不存在则设为1）
            hash.put(sum, hash.getOrDefault(sum, 0) + 1);
        }
        return ret;
    }
}

注意 :

1. 需要初始化 hash0 = 1 ,如果没有初始化 , 当第一个元素等于 k 时 , 执行到hash.getOrDefault(sum - k, 0) , 会返回 0 , 漏双这次
2. 先查 hash 表再更新哈希表

如果先更新哈希表 再查 hash 表 ; 使用以上示例 出现这种情况 , 先执行 hash.put(sum, hash.getOrDefault(sum, 0) + 1), 将 hashsum = 1 ; 然后再执行ret += hash.getOrDefault(sum - k, 0) , 找 哈希表中 hashsum 的 value , 此时会返回 1

练习三 : 和可被 k 整除的子数组

974. 和可被 K 整除的子数组 - 力扣（LeetCode）

class Solution {
    public int subarraysDivByK(int[] nums, int k) {
        Map<Integer,Integer> hash = new HashMap<>();
        int sum = 0,ret = 0;
        hash.put(0,1);
        for(int x:nums){
            sum+=x;
            int modulus = (sum%k+k)%k;
            ret+=hash.getOrDefault(modulus,0);
            hash.put(modulus,hash.getOrDefault(modulus,0)+1);
        }
        return ret;
    }
}

补充 :

1. 通过同余定理等到 : (sum- 某一前缀和)等到子数组元素之和 , 要找(sum-前缀和)%k = 0 ; sum%k = 某一前缀和%k ; 如果此时哈希表中正好存的是余数 , 就可以直接查询
2. 处理负数求余数 , 在 Java 中余数的符号由第一个操作数的符号决定 , 所以在复苏求余数时需要经过以下处理 : (sum%k+k)%k 解释如下 : 第一次求余数如果是负数 , 且这个负数的绝对值小于 k , 那么加上一个 k 之后就会等到正数 , 再取余数就完成操作

算法原理同上题

练习四 ： 连续数组

https://leetcode.cn/problems/contiguous-array/https://leetcode.cn/problems/contiguous-array/

class Solution {
    public int findMaxLength(int[] nums) {
        Map<Integer,Integer> hash = new HashMap<>();
        hash.put(0,-1);
        for(int i = 0;i<nums.length;i++){
            if(nums[i] == 0){
                nums[i] = -1;
            }
        }
        int sum = 0;
        int ret = 0;
        for(int i = 0;i<nums.length;i++){
            sum+=nums[i];
            if(hash.containsKey(sum)){
                ret = Math.max(i-hash.get(sum),ret);
            } 
            else hash.put(sum,i);
            
        }
        return ret;
    }
}

算法原理 ：

1. 将所有的 0 转化为－1 ， 这样就能把求相同数量的 0，1 转化为求子数组元素之和为 0；
2. 每计算一个前缀和 ， 如果这个前缀和在哈希表中，说明这两个下标之间的元素之和为 0，并且更新最大长度；如果不在哈希表中，就存入前缀和和下标
3. 细节问题 : 如何处理第一个数就为 0 的情况 ；hash.put(0,-1), 此时如果第一个元素就为 0 ，长度就为 0-(-1) = 1 , 符合题意