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

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

class Solution {
public:
    int my_sum(int x){
        int sum = 0;
        for(int i = 1;i < x;i++)
            sum+=i;
        return sum;
    }
    int subarraysDivByK(vector<int>& A, int K) {
        vector<int>sum;
        vector<int>a(K,0);
        vector<int>b(K,0);
        int ans = 0;
        sum.push_back(A[0]);
        for(int i = 1;i < A.size();i++)
            sum.push_back(A[i] + sum[i - 1]);
        for(int i = 0;i < sum.size();i++){
            if(sum[i] >= 0) a[sum[i] % K]++;
            else b[abs(sum[i]) % K]++;
        }
        for(int i = 0;i < K;i++){
            ans+=(my_sum(a[i]) + my_sum(b[i]));
            if(i != 0 && a[i] != 0 && b[K - i] != 0) ans+=a[i] * b[K - i];
        }
        ans += a[0] + b[0] + a[0] * b[0];
        return ans;
    }
};

解题思路：1 <= A.length <= 30000所以暴力是肯定不可以的，首先用一个vector : sum来存储前n个数的和，这样的话sum里面任意两个数相减就是一段连续的子序列之和，然后利用a,b两个向量来存储sum中正数和负数取余之后各个数的个数，其中负数先取绝对值再取余数。而能否被整除余数至关重要，只有当以下几种情况时这个子序列才可以被K整除

1.同一个余数的子序列大于1，这里的子序列是0 - i（i<n），所以相减之后余数为零即可以被整除（正数和负数分别计算，因为正数和负数相减之后是不一定被整除的）（例如 1 - （-1） = 2，但是余数都是1，所以分开存储）。        

2.当正数余数和负数余数相加刚好为K时是可以的，（例如K = 3，1 - （-2） = 3 是可以被整除的）

3.对于原本余数就为0的0 - i 的子序列不需要进行加减也是可以的被K整除的。

4.当正数余数和负数余数都为0时是可以进行相减得到新的子序列的，这里和第二个有点相似应该可以写到一起，读者有兴趣可以试一试。

例子分析：[7,-5,5,-8,-6,6,-4,7,-8,-7]  K = 7

sum[7,2,7,-1,-7,-1,-5,2,-6,-13]  取余数之后 [0,2,0,-1,-0,-1,-5,2,-6,-6]

对应的a[2，0，2，0，0，0，0]

               0   1    2    3   4   5    6

对应b [1，2，0，0，0，1，2]

            0   1    2    3   4    5   6

对于情况一：a中a[0] = a[2] = 2，所以是有 1 + 1 = 2种情况

                      b中a[1] = a[6] = 2, 所以是1 + 1 = 2种情况

对于情况二：  a[2] 和 b[5] ，排列组合，所以是 a[2] * b[5] = 2种情况

对于情况三：a[0] = 2,b[0] = 1 ,所以是1 + 2 = 3种情况

对于情况四 ：a[0] * b[0] = 2种情况

所以结果是11种。