[LeetCode]974. 和可被 K 整除的子数组

题目

给定一个整数数组 A，返回其中元素之和可被 K 整除的（连续、非空）子数组的数目。

示例：

输入：A = [4,5,0,-2,-3,1], K = 5
输出：7
解释：
有 7 个子数组满足其元素之和可被 K = 5 整除：
[4, 5, 0, -2, -3, 1], [5], [5, 0], [5, 0, -2, -3], [0], [0, -2, -3], [-2, -3]

提示：

1. 1 <= A.length <= 30000
2. -10000 <= A[i] <= 10000
3. 2 <= K <= 10000

解题思路

本题与（560. 和为K的子数组）非常类似，详情可参考560. 和为K的子数组
解法一：前缀和 + 哈希表优化
定义数组 sum[j] 为[0…j]所有元素的和，那么[i…j]这个子数组的和可以表示为 s[i…j]=sum[j]-sum[i-1]，要使这个子数组的和可被k整除，即 (sum[j]-sum[i-1]) mod k == 0，也即 sum[j] mod k == sum[i-1] mod k。因此只需要找有多少对累加和sum mod k 相同的数就可以组合一下得到结果。
这可以借助哈希表保存累加和sum mod k的值以及出现的次数，若相同的(sum mod k)已经出现过，则说明存在连续子数组之和可被k整除。由于 sum[i] 的计算只与前一项的答案有关，因此我们可以不用建立 sum 数组，直接用一个 sum 变量来记录 sum[i−1] 的答案即可。

具体做法是：
1）初始化哈希表hash={0:1}，表示累加和sum mod k=0，出现了1次。初始化累加和sum=0。初始化结果res=0。
2）遍历数组：
2.1）更新累加和sum += nums[i]；
2.2）若sum mod k存在于hash中，说明存在连续子数组之和可被k整除。则令res += hash[sum mod k]，表示sum mod k出现几次，就存在几种子数组之和可被k整除。
2.3）若sum mod k 存在于hash中，将其出现次数加一。若不存在，将其加入hash。
3）返回res。

复杂度分析：
时间复杂度：O(N)，其中 N 是数组 A 的长度。我们只需要从前往后遍历一次数组，在遍历数组的过程中，维护哈希表的各个操作均为 O(1)，因此总时间复杂度为 O(N)。
空间复杂度：O(min(N,K))，即哈希表需要的空间。当 N≤K 时，最多有 N 个前缀和，因此哈希表中最多有 N+1 个键值对；当 N>K 时，最多有 K 个不同的余数，因此哈希表中最多有 K 个键值对。也就是说，哈希表需要的空间取决于 N 和 K 中的较小值。

注：
本题有个注意点，取模与取余的区别，其实取模和取余在目标上是一致的，但是因为语言对取余和取模上定义的不同，导致得到的结果不同。对取余和取模定义不同的语言中，两者的不同点只有一个：
1）取余运算在计算商值向0方向舍弃小数位；
2）取模运算在计算商值向负无穷方向舍弃小数位。
或者也可以这样理解：
1）取余，遵循尽可能让商大的原则
2）取模，遵循尽可能让商小的原则
从上面的区别可以总结出，取余（rem）和取模（mod）在被除数、除数同号时，结果是等同的，异号时会有区别，所以要特别注意异号的情况。

一些例子：
取余：

5 rem 3 = 2 （5=1*3+2，商为1）
-5 rem 3 = -2 （-5=(-1)*3-2，商为-1）
5 rem -3 = 2 （5=(-1)*(-3)+2，商为-1）
-5 rem -3 = -2 （-5=1*(-3)-2，商为1）

取模：

5 mod 3 = 2 （5=1*3+2，商为1）
-5 mod 3 = 1 （-5=(-2)*3+1，商为-2）
5 mod -3 = -1 （5=(-2)*(-3)-1，商为-2）
-5 mod -3 = -2 （-5=1*(-3)-2，商为1）

在C/C++, C#, JAVA, PHP这几门主流语言中，’%’运算符都是做取余运算，而在python中的’%’是做取模运算。

代码

Python代码如下：

class Solution:
    def subarraysDivByK(self, A: List[int], K: int) -> int:
        hash_dic = {0:1}
        res = 0
        s = 0
        for i in range(len(A)):
            s += A[i]
            if s % K in hash_dic:
                res += hash_dic[s%K]
                hash_dic[s%K] += 1
            else:
                hash_dic[s%K] = 1
        return res

Java代码如下：

class Solution {
    public int subarraysDivByK(int[] A, int K) {
        HashMap<Integer, Integer> hash = new HashMap<Integer, Integer>();
        hash.put(0, 1);
        int res = 0;
        int s = 0;
        for(int i=0; i<A.length; i++){
            s += A[i];
            int mod = Math.floorMod(s, K);
            if(hash.containsKey(mod)){
                res += hash.get(mod);
                hash.put(mod, hash.get(mod)+1);
            }else{
                hash.put(mod, 1);
            }
        }
        return res;
    }
}