算法复盘 ~ 前缀和经典问题 ~ 连续的子数组和

连续的子数组和

523. 连续的子数组和

给你一个整数数组 nums 和一个整数 k ，编写一个函数来判断该数组是否含有同时满足下述条件的连续子数组：

子数组大小 至少为 2 ，且子数组元素总和为 k 的倍数。如果存在，返回 true ；否则，返回 false 。

如果存在一个整数 n ，令整数 x 符合 x = n * k ，则称 x 是 k 的一个倍数。

输入：nums = [23,2,4,6,7], k = 6
输出：true
解释：[2,4] 是一个大小为 2 的子数组，并且和为 6 。

思路一：暴力，求出所有的长度为2的子数组，然后进行求和判断是否是k的倍数，这样下来的时间复杂度度为O(n2) * O(n)，因为计算子数组的和需要花费o(n)的时间，超时

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        if(nums.length == 1) return false;
        for(int i = 0;i < nums.length;i++){
            for(int j = i + 1;j < nums.length;j++){
                if( add(nums, i, j) % k == 0)    return true;
            }
        }
        return false;
    }   
    public int add(int[] nums, int i, int j){
        int res = 0;
        for(int p = i;p <= j;p++){
            res += nums[p];
        }
        return res;
    }
}

思路二：在思路一的前提上，进行优化，可以使用前缀和，因为对于子树组下标为[i, j]的和来说，有以下两种情况：

• i == 0：sum[i, j] = sum[j]
• i != 0 ：sum[i, j] = sum[j] - sum[i - 1]

这样下来就优化了子数组求和的过程，时间复杂度为O(n2)，还是超时

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        if(nums.length == 1) return false;
        int[] sum = new int[nums.length];
        sum[0] = nums[0];
        for(int i = 1;i < nums.length;i++){
            sum[i] = sum[i - 1] + nums[i]; 
        }
        for(int i = 0;i < nums.length;i++){
            for(int j = i + 1;j < nums.length;j++){
                if((i == 0 && sum[j] % k == 0) || (i != 0 && (sum[j] - sum[i - 1] ) % k == 0))return true;
            }
        }
        return false;
    }   

}

思路三：对于下标为i,j 之间的子数组，如果该和是k的倍数，那么有以下成立：

sum[i - 1] % k = sum[j] % k，例如对于数据[23, 2, 4, 6, 7]，前缀和为[23, 25, 29, 35, 42] k = 6，那么余数的结果为[5, 1, 5, 5, 0]，那么很显然下标为[1,2]为正确的子数组

那么可以使用一个哈希表（余数，下标）存储当前的余数，如果当前的余数在哈希表中已经存在，那么取出该下标j， 同时判断当前数的下标看这个子数组的长度是否大于2，如果不存在则将该余数存入哈希表中

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        if(nums.length == 1) return false;
        int[] sum = new int[nums.length];
        sum[0] = nums[0];
        for(int i = 1;i < nums.length;i++){
            sum[i] = sum[i - 1] + nums[i];
        }
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0;i < nums.length;i++){
            int digit = sum[i] % k;
            //需要注意余数本身为0的情况 [23, 2, 4, 6, 6] k = 7
            if(digit == 0){
                if(i >= 1) return true;
            }
            if(map.get(digit) != null){
                int p = map.get(digit);
                if(i - p > 1) return true;
            }else{
                map.put(digit, i);
            }
        }
        return false;
    }