[Leedcode][JAVA][第974题][和可被K整除的子数组][前缀和][HashSet]

【问题描述】[中等]

给定一个整数数组 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. 暴力（不通过）

时间复杂度：O(N^2) 空间复杂度：O(1)

      public int subarraysDivByK(int[] A, int K) {
           int n = A.length;
           int res = 0;
           for (int i = 0; i < n; ++i) {
               int sum = 0;
               for (int j = i; j < n; ++j) {
                   if ((sum += A[j]) % K == 0) {
                       ++res;
                   }
               }
           }
           return res;
       }

2. 前缀和 同余思想

转化为同余的思想

时间复杂度：O(N) 空间复杂度：O(N)

数组维护

 // 计算同余法
    // 用sum保存前n个数之和
    // 计算每个sum的余数，保存
    // 余数相同则可以整除 ， 如
    // A = [4,5,0,-2,-3,1], K = 5
    // p[0] = 4, p[1] = 9, p[2] = 9, p[3] = 7, p[4] = 4, p[5] = 5
    // 余数对应 4,4,4,2,4,0;
    // 余数4有4个，排列组合法，计算4*3/2 = 6
    // 0余数相当于整除，用排列组合法(初始0赋值1)， 2*1/2 = 1;
    // 最终答案为7



 public int subarraysDivByK(int[] A, int K) {
        int res = 0;
        // 记录当前前缀和
        int preSum = 0;
        // 因为K固定，因此可以使用数组代替哈希表（mod[i] = j，代表余数为i的前缀和出现了j次）
        int[] mod = new int[K];
        // 余数为0的状况，也就是直接被整除的情况，要提前放个1，考虑比如 A = {K}
        mod[0] = 1;
        for (int value : A) {
            // 更新前缀和
            preSum += value;
            // 计算mod（java注意）
            int m = (preSum % K + K) % K;
            // 更新结果
            res += mod[m];
            // 更新余数集记录
            ++mod[m];
        }
        return res;
    }

HashSet

class Solution {
    public int subarraysDivByK(int[] A, int K) {
        Map<Integer, Integer> record = new HashMap<>();
        record.put(0, 1);
        int sum = 0, ans = 0;
        for (int elem: A) {
            sum += elem;
            // 注意 Java 取模的特殊性，当被除数为负数时取模结果为负数，需要纠正
            int modulus = (sum % K + K) % K;
            int same = record.getOrDefault(modulus, 0);
            ans += same;
            record.put(modulus, same + 1);
        }
        return ans;
    }
}

【总结】

1.取余问题

• 对于任何同号的两个整数，其取余结果没有争议，所有语言的运算原则都是使商尽可能小。
• 对于异号的两个整数，C++/Java语言的原则是使商尽可能大，很多新型语言和网页计算器的原则是使商尽可能小。

//被除数是负数
C++（G++ 编译）： cout << (-7) % 3; // 输出 -1


Java（1.6）： System.out.println((-7) % 3); // 输出 -1


Python 2.6：>>>  (-7) % 3 // 输出 2


百度计算器：(-7) mod 3 = 2


Google 计算器：(-7) mod 3 = 2
//除数是负数
C++（G++ 编译）： cout << 7 % (-3); // 输出 1


Java（1.6）： System.out.println(7 % (-3)); // 输出 1


Python 2.6：>>>  输出 -2


百度计算器：7 mod (-3) = -2


Google 计算器： 7 mod (-3) = -2】

//被除数和除数同为负号
C++（G++ 编译）： cout << (-7) % (-3); // 输出 -1


Java（1.6）： System.out.println((-7) % (-3)); // 输出 -1


Python 2.6：>>>  输出 -1


百度计算器：-7 mod (-3) = -1


Google 计算器： -7 mod (-3) = -1

2. 前缀和 涉及到数组求和

3.数学是个好东西

转载链接：https://leetcode-cn.com/problems/subarray-sums-divisible-by-k/solution/guan-fang-ti-jie-tong-yu-fa-by-qi-xi-5/

参考链接：https://leetcode-cn.com/problems/subarray-sums-divisible-by-k/solution/he-ke-bei-k-zheng-chu-de-zi-shu-zu-by-leetcode-sol/
参考链接：http://ceeji.net/blog/mod-in-real/