LeetCode 523. 连续的子数组和

523. 连续的子数组和

给你一个整数数组 nums 和一个整数 k ，如果 nums 有一个 好的子数组 返回 true ，否则返回 false：

一个 好的子数组 是：

• 长度 至少为 2 ，且
• 子数组元素总和为 k 的倍数。

注意：

• 子数组 是数组中 连续 的部分。
• 如果存在一个整数 n ，令整数 x 符合 x = n * k ，则称 x 是 k 的一个倍数。0 始终 视为 k 的一个倍数。

示例 1：

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

示例 2：

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

示例 3：

输入：nums = [23,2,6,4,7], k = 13
输出：false

提示：

• 1 <= nums.length <= 10^5
• 0 <= nums[i] <= 10^9
• 0 <= sum(nums[i]) <= 2^31 - 1
• 1 <= k <= 2^31 - 1

解法1：前缀和 + 哈希集

我们需要从 k 的倍数作为切入点来做。

预处理前缀和数组 presum，方便快速求得某一段区间的和。然后假定 [i,j] 是我们的目标区间，那么有：

presum[j] − presum[i−1]=n∗k
经过简单的变形可得：
要使得两者除 k 相减为整数，需要满足 presum[j] 和 presum[i−1] 对 k 取余相同。

也就是说，我们只需要枚举右端点 j，然后在枚举右端点 j 的时候检查之前是否出现过左端点 i，使得 presum[j] 和 presum[i−1] 对 k 取余相同。

具体的，使用 HashSet 来保存出现过的值。

让循环从 2 开始枚举右端点（根据题目要求，子数组长度至少为 2），每次将符合长度要求的位置的取余结果存入 HashSet。

如果枚举某个右端点 j 时发现存在某个左端点 i 符合要求，则返回 True。

Java版：

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        int n = nums.length;
        int[] presum = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            presum[i] = presum[i - 1] + nums[i - 1];
        }
        Set<Integer> set = new HashSet<>();
        for (int i = 2; i <= n; i++) {
            set.add(presum[i - 2] % k);
            if (set.contains(presum[i] % k)) {
                return true;
            }
        }
        return false;
    }
}

Python3版：

class Solution:
    def checkSubarraySum(self, nums: List[int], k: int) -> bool:
        n = len(nums)
        presum = [0] * (n + 1)
        for i in range(1, n + 1):
            presum[i] = presum[i - 1] + nums[i - 1]
        record = set()
        for i in range(2, n + 1):
            record.add(presum[i - 2] % k)
            if presum[i] % k in record:
                return True
        return False

复杂度分析

• 时间复杂度：O(n)，n 是数组 nums 的长度。
• 空间复杂度：O(n)，n 是数组 nums 的长度。

解法2：前缀和 + 哈希表

如果事先计算出数组 nums 的前缀和数组，则对于任意一个子数组，都可以在 O(1) 的时间内得到其元素和。用 prefixSums[i] 表示数组 nums 从下标 0 到下标 i 的前缀和，则 nums 从下标 p+1 到下标 q（其中 p<q）的子数组的长度为 q−p，该子数组的元素和为 prefixSums[q]−prefixSums[p]。

如果 prefixSums[q]−prefixSums[p] 为 k 的倍数，且 q−p≥2，则上述子数组即满足大小至少为 2 且元素和为 k 的倍数。

当 prefixSums[q]−prefixSums[p] 为 k 的倍数时，prefixSums[p] 和 prefixSums[q] 除以 k 的余数相同。因此只需要计算每个下标对应的前缀和除以 k 的余数即可，使用哈希表存储每个余数第一次出现的下标。

规定空的前缀的结束下标为 −1，由于空的前缀的元素和为 0，因此在哈希表中存入键值对 (0,−1)。对于 0≤i<m，从小到大依次遍历每个 i，计算每个下标对应的前缀和除以 k 的余数，并维护哈希表：

如果当前余数在哈希表中已经存在，则取出该余数在哈希表中对应的下标 prevIndex，nums 从下标 prevIndex+1 到下标 i 的子数组的长度为 i−prevIndex，该子数组的元素和为 k 的倍数，如果 i−prevIndex≥2，则找到了一个大小至少为 2 且元素和为 k 的倍数的子数组，返回 true；

如果当前余数在哈希表中不存在，则将当前余数和当前下标 i 的键值对存入哈希表中。

由于哈希表存储的是每个余数第一次出现的下标，因此当遇到重复的余数时，根据当前下标和哈希表中存储的下标计算得到的子数组长度是以当前下标结尾的子数组中满足元素和为 k 的倍数的子数组长度中的最大值。只要最大长度至少为 2，即存在符合要求的子数组。

Java版：

class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        int n = nums.length;
        Map<Integer, Integer> record = new HashMap<>();
        int presum = 0;
        record.put(0, -1);
        for (int i = 0; i < n; i++) {
            presum = (presum + nums[i]) % k;
            if (record.containsKey(presum)) {
                if (i - record.get(presum) >= 2) {
                    return true;
                }
            } else {
                record.put(presum, i);
            }
        }
        return false;
    }
}

Python3版：

class Solution:
    def checkSubarraySum(self, nums: List[int], k: int) -> bool:
        record = dict()
        presum = 0
        record[0] = -1 
        for i, num in enumerate(nums):
            presum = (presum + num) % k
            if presum in record:
                if i - record[presum] >= 2:
                    return True
            else:
                record[presum] = i 
        return False

复杂度分析

• 时间复杂度：O(n)，其中 n 是数组 nums 的长度。需要遍历数组一次。
• 空间复杂度：O(min(n,k))，其中 n 是数组 nums 的长度。空间复杂度主要取决于哈希表，哈希表中存储每个余数第一次出现的下标，最多有 min(n,k) 个余数。