[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 <= A.length <= 30000
-10000 <= A[i] <= 10000 2 <= K <= 10000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/subarray-sums-divisible-by-k
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

对于这道题目，我的第一反应是滑动窗口。但是由于题目中要求求的数组存在真包含的原因，滑动窗口在这题不是很适用。考虑到是同余问题，那么就可以用类似动态规划的方法。用一个长度为ASize的数组，第i位记录前i位的总和关于K的模。如果数组中第3位到第5位的和整除K，那就意味着数组和前（3-1）位和前5位关于K的模一定一样。
然后统计数组中的关于K的余数个数，由排列组合知道当K不等于0的时候，一定是count * (count -1).根据这个思路，很容易就能写出代码。

这里有一个需要注意的地方，就是C语言的取模机制，直接取模可能会出现负数。
图中是-15到14关于5的余数，大家看了就应该能明白我的意思了。

可以用这种方式解决：

 A[i] = (A[i-1] + A[i]) % K;
        while (A[i] < 0) {     //这个if不加会报错，可能是编译环境的问题
            A[i] += K;
        }

如果觉得繁琐就可以这样：

j=(sum%K+K)%K;

代码1

int subarraysDivByK(int* A, int ASize, int K){
    if (ASize == 1) {
        if (A[0] % K == 0) {
            return 1;
        } else {
            return 0; 
        }
    }
    int count[K+1],sum = 0;
    A[0] = A[0] % K; 
    while (A[0] < 0) {
        A[0] += K;
    }
    for (int i = 1; i < ASize; i++) {
        A[i] = (A[i-1] + A[i]) % K;
        while (A[i] < 0) {     //这个if不加会报错，可能是编译环境的问题
            A[i] += K;
        }
    }
    for (int i = 0; i < K; i++) {
        count[i] = 0; 
    }
    for (int i = 0; i < ASize; i++) {
        // printf("%d,",A[i]);
        count[A[i]]++;
    }
    sum += count[0]*(count[0] + 1)/2;
    for (int i = 1; i < K; i++) {
        sum += count[i] * (count[i] - 1)/2;
    }
    return sum;
}

结果1

代码2

基于上面的代码，在思路不变的前提下做了些优化，其实就是把n(n-1)改成了1+2+……+（n-1），减少了一次循环。效果提升不算明显，但是总体来看还是会好一些。

int subarraysDivByK(int* A, int ASize, int K){
    int i,j,sum=0,count=0,p=K;
    int *arry=(int*)malloc(sizeof(int)*K);
    for(j=1;j<K;j++) arry[j]=0;
    arry[0]=1;
    for(i=1;i<=ASize;i++) {
        sum+=A[i-1];
        j=(sum%K+K)%K;
        count+=arry[j];
        arry[j]++;
    }
    return count;
}

结果2

感谢大家的支持和点赞。