计算可被 K 整除的子数组

Question

给定一个由 n 个正整数组成的序列，我们需要计算其和可被 k 整除的连续子序列。

约束：N 最大为 10^6，每个元素最大为 10^9，K 最大为 100

示例：设 N=5 和 K=3 且数组为 1 2 3 4 1

这里的答案是 4

解释：存在4个子序列，其和能被3整除，它们是

3
1 2
1 2 3
2 3 4

我的尝试：

long long int count=0;
for(int i=0;i<n;i++){
    long long int sum=0;
    for(int j=i;j<n;j++)
    {
        sum=sum+arr[j];
        if(sum%k==0)
        {
            count++;
        }
    }
}

但显然它的方法很糟糕。他们可以更好地解决这个问题吗？请帮忙。

完整问题：https://www.hackerrank.com/contests/w6/challenges/consecutive-subsequences

Answer 1

这是一个快速的 O(n + k) 解决方案：

1) 计算前缀和 pref[i](for 0

2)现在我们可以计算 count[i]——总和为 i 模 k(0

3)答案是所有 i 的 sum count[i] * (count[i] - 1) / 2。

4) 最好以 k 为模计算前缀和以避免溢出。

为什么有效？让我们仔细看看可被 k 整除的子数组。假设它从 L 位置开始并在 R 位置结束。它可以被 k 整除当且仅当 pref[L - 1] == pref[R] (模 k) 因为它们的差是模 k 为零（根据可除性的定义）。所以对于每个固定的模数，我们可以选择任意两个前缀和这个前缀和模数 k（并且恰好有 count[i] * (count[i] - 1) / 2 种方法）。

这是我的代码：

long long get_count(const vector<int>& vec, int k) {
  //Initialize count array.
  vector<int> cnt_mod(k, 0);
  cnt_mod[0] = 1;
  int pref_sum = 0;
  //Iterate over the input sequence.
  for (int elem : vec) {
    pref_sum += elem;
    pref_sum %= k;
    cnt_mod[pref_sum]++;
  }
  //Compute the answer.
  long long res = 0;
  for (int mod = 0; mod < k; mod++)
    res += (long long)cnt_mod[mod] * (cnt_mod[mod] - 1) / 2;
  return res;
}

Answer 2

这必须使您的计算更容易：

//Now we will move all numbers to [0..K-1]
long long int count=0;
for(int i=0;i<n;i++){
    arr[i] = arr[i]%K;
}

//Now we will calculate cout of all shortest subsequences.
long long int sum=0; 
int first(0); 
std::vector<int> beg;
std::vector<int> end;
for(int i=0;i<n;i++){
    if (arr[i] == 0)
    {
        count++; 
        continue;
    }
    sum += arr[i];
    if (sum == K)
    {
        beg.push_back(first);
        end.push_back(i);
        count++;
    }
    else
    {
        while (sum > K)
        {
            sum -= arr[first];
            first++;     
        }
        if (sum == K)
        {
            beg.push_back(first);
            end.push_back(i);
            count++;
        }
    }        
}

//this way we found all short subsequences. And we need to calculate all subsequences that consist of some short subsequencies.
int party(0);
for (int i = 0; i < beg.size() - 1; ++i)
{
    if (end[i] == beg[i+1])
    {
        count += party + 1;
        party++;
    }
    else
    {
        party = 0;
    } 
}

因此，最大数组大小 = 10^6 和最大剩余大小 = 99，即使您需要对简单 int32 中的所有数字求和，也不会溢出。

您将花费的时间大约为 O(n+n)