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⁵
0 <= nums[i] <= 10⁹
0 <= sum(nums[i]) <= 2³¹ - 1
1 <= k <= 2³¹ - 1

解法

方法一：前缀和 + 哈希表

根据题目描述，如果存在两个前缀和模 \(k\) 的余数相同的位置 \(i\) 和 \(j\)（不妨设 \(j < i\)），那么 \(\textit{nums}[j+1..i]\) 这个子数组的和是 \(k\) 的倍数。

因此，我们可以使用哈希表存储每个前缀和模 \(k\) 的余数第一次出现的位置。初始时，我们在哈希表中存入一对键值对 \((0, -1)\)，表示前缀和为 \(0\) 的余数 \(0\) 出现在位置 \(-1\)。

遍历数组时，我们计算当前前缀和的模 \(k\) 的余数，如果当前前缀和的模 \(k\) 的余数没有在哈希表中出现过，我们就将当前前缀和的模 \(k\) 的余数和对应的位置存入哈希表中。否则，如果当前前缀和的模 \(k\) 的余数在哈希表中已经出现过，位置为 \(j\)，那么我们就找到了一个满足条件的子数组 \(\textit{nums}[j+1..i]\)，因此返回 \(\textit{True}\)。

遍历结束后，如果没有找到满足条件的子数组，我们返回 \(\textit{False}\)。

时间复杂度 \(O(n)\)，空间复杂度 \(O(n)\)。其中 \(n\) 是数组 \(\textit{nums}\) 的长度。

Python3JavaC++GoTypeScript

class Solution:
    def checkSubarraySum(self, nums: List[int], k: int) -> bool:
        d = {0: -1}
        s = 0
        for i, x in enumerate(nums):
            s = (s + x) % k
            if s not in d:
                d[s] = i
            elif i - d[s] > 1:
                return True
        return False

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

class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        unordered_map<int, int> d{{0, -1}};
        int s = 0;
        for (int i = 0; i < nums.size(); ++i) {
            s = (s + nums[i]) % k;
            if (!d.contains(s)) {
                d[s] = i;
            } else if (i - d[s] > 1) {
                return true;
            }
        }
        return false;
    }
};

func checkSubarraySum(nums []int, k int) bool {
    d := map[int]int{0: -1}
    s := 0
    for i, x := range nums {
        s = (s + x) % k
        if _, ok := d[s]; !ok {
            d[s] = i
        } else if i-d[s] > 1 {
            return true
        }
    }
    return false
}

function checkSubarraySum(nums: number[], k: number): boolean {
    const d: Record<number, number> = { 0: -1 };
    let s = 0;
    for (let i = 0; i < nums.length; ++i) {
        s = (s + nums[i]) % k;
        if (!d.hasOwnProperty(s)) {
            d[s] = i;
        } else if (i - d[s] > 1) {
            return true;
        }
    }
    return false;
}

523. 连续的子数组和

题目描述

解法

方法一：前缀和 + 哈希表

评论