计算总和模 K 与子数组长度相同的子数组

给定一个整数K和一个由N 个正整数组成的数组arr[] ，任务是找到其和模K等于子数组大小的子数组的数量。

例子：

Input: arr[] = {1, 4, 3, 2}, K = 3
Output: 4
Explanation: 
1 % 3 = 1 
(1 + 4) % 3 = 2 
4 % 3 = 1 
(3 + 2) % 3 = 2 
Therefore, subarrays {1}, {1, 4}, {4}, {3, 2} satisfy the required conditions.

Input: arr[] = {2, 3, 5, 3, 1, 5}, K = 4
Output: 5
Explanation: 
The subarrays (5), (1), (5), (1, 5), (3, 5, 3) satisfy the required condition.

朴素方法：最简单的方法是找到给定数组的前缀和，然后生成前缀和数组的所有子数组，并计算和模K等于该子数组长度的子数组。打印获得的子数组的最终计数。

下面是上述方法的实现：

C++

// C++ program of the above approach
 
#include 
using namespace std;
 
// Function that counts the subarrays
// having sum modulo k equal to the
// length of subarray
 
long long int countSubarrays(
    int a[], int n, int k)
{
 
    // Stores the count
    // of subarrays
    int ans = 0;
 
    // Stores prefix sum
    // of the array
    vector pref;
    pref.push_back(0);
 
    // Calculate prefix sum array
    for (int i = 0; i < n; i++)
        pref.push_back((a[i]
                        + pref[i])
                       % k);
 
    // Generate all the subarrays
    for (int i = 1; i <= n; i++) {
        for (int j = i; j <= n; j++) {
 
            // Check if this subarray is
            // a valid subarray or not
            if ((pref[j] - pref[i - 1] + k) % k
                == j - i + 1) {
                ans++;
            }
        }
    }
 
    // Total count of subarrays
    cout << ans << ' ';
}
 
// Driver Code
int main()
{
    // Given arr[]
    int arr[] = { 2, 3, 5, 3, 1, 5 };
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Given K
    int K = 4;
 
    // Function Call
    countSubarrays(arr, N, K);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
import java.lang.*;
import java.io.*;
 
class GFG{
     
// Function that counts the subarrays
// having sum modulo k equal to the
// length of subarray
static void countSubarrays(int a[], int n,
                           int k)
{
     
    // Stores the count
    // of subarrays
    int ans = 0;
   
    // Stores prefix sum
    // of the array
    ArrayList pref = new ArrayList<>();
    pref.add(0);
   
    // Calculate prefix sum array
    for(int i = 0; i < n; i++)
        pref.add((a[i] + pref.get(i)) % k);
   
    // Generate all the subarrays
    for(int i = 1; i <= n; i++)
    {
        for(int j = i; j <= n; j++)
        {
             
            // Check if this subarray is
            // a valid subarray or not
            if ((pref.get(j) -
                 pref.get(i - 1) + k) %
                     k == j - i + 1)
            {
                ans++;
            }
        }
    }
   
    // Total count of subarrays
    System.out.println(ans);
}
 
// Driver Code
public static void main (String[] args)
throws java.lang.Exception
{
     
    // Given arr[]
    int arr[] = { 2, 3, 5, 3, 1, 5 };
     
    // Size of the array
    int N = arr.length;
     
    // Given K
    int K = 4;
     
    // Function call
    countSubarrays(arr, N, K);
}
}
 
// This code is contributed by bikram2001jha

Python3

# Python3 program for the above approach
  
# Function that counts the subarrays
# having sum modulo k equal to the
# length of subarray
def countSubarrays(a, n, k):
  
    # Stores the count
    # of subarrays
    ans = 0
  
    # Stores prefix sum
    # of the array
    pref = []
    pref.append(0)
  
    # Calculate prefix sum array
    for i in range(n):
        pref.append((a[i] + pref[i]) % k)
  
    # Generate all the subarrays
    for i in range(1, n + 1, 1):
        for j in range(i, n + 1, 1):
  
            # Check if this subarray is
            # a valid subarray or not
            if ((pref[j] -
                 pref[i - 1] + k) %
                      k == j - i + 1):
                ans += 1
             
    # Total count of subarrays
    print(ans, end = ' ')
 
# Driver Code
 
# Given arr[]
arr = [ 2, 3, 5, 3, 1, 5 ]
  
# Size of the array
N = len(arr)
  
# Given K
K = 4
  
# Function call
countSubarrays(arr, N, K)
 
# This code is contributed by sanjoy_62

C#

// C# program for the above approach 
using System;
using System.Collections.Generic;
 
class GFG{
  
// Function that counts the subarrays
// having sum modulo k equal to the
// length of subarray
static void countSubarrays(int[] a, int n,
                            int k)
{
     
    // Stores the count
    // of subarrays
    int ans = 0;
    
    // Stores prefix sum
    // of the array
    List pref = new List();
    pref.Add(0);
    
    // Calculate prefix sum array
    for(int i = 0; i < n; i++)
        pref.Add((a[i] + pref[i]) % k);
    
    // Generate all the subarrays
    for(int i = 1; i <= n; i++)
    {
        for(int j = i; j <= n; j++)
        {
             
            // Check if this subarray is
            // a valid subarray or not
            if ((pref[j] -
                 pref[i - 1] + k) %
                      k == j - i + 1)
            {
                ans++;
            }
        }
    }
    
    // Total count of subarrays
    Console.WriteLine(ans);
}
  
// Driver Code
public static void Main ()
{
     
    // Given arr[]
    int[] arr = { 2, 3, 5, 3, 1, 5 };
      
    // Size of the array
    int N = arr.Length;
      
    // Given K
    int K = 4;
      
    // Function call
    countSubarrays(arr, N, K);
}
}
 
// This code is contributed by sanjoy_62

Javascript

// Javascript program of the above approach
 
// Function that counts the subarrays
// having sum modulo k equal to the
// length of subarray
 
function countSubarrays( a, n, k)
{
 
    // Stores the count
    // of subarrays
    var ans = 0;
 
    // Stores prefix sum
    // of the array
    var pref = [];
    pref.push(0);
 
    // Calculate prefix sum array
    for (var i = 0; i < n; i++)
        pref.push((a[i]
                        + pref[i])
                       % k);
 
    // Generate all the subarrays
    for (var i = 1; i <= n; i++) {
        for (var j = i; j <= n; j++) {
 
            // Check if this subarray is
            // a valid subarray or not
            if ((pref[j] - pref[i - 1] + k) % k
                == j - i + 1) {
                ans++;
            }
        }
    }
 
    // Total count of subarrays
    document.write( ans + ' ');
}
 
// Driver Code
 
// Given arr[]
var arr = [ 2, 3, 5, 3, 1, 5 ];
 
// Size of the array
var N = arr.length;
 
// Given K
var K = 4;
 
// Function Call
countSubarrays(arr, N, K);
 
// This code is contributed by itsok.

输出：

5

时间复杂度： O(N ² )
辅助空间： O(1)

高效方法：想法是生成给定数组的前缀和，然后问题减少到子数组的数量，使得(pref[j] – pref[i]) % K等于(j – i) ，其中j > i和(j − i) ≤ K。以下是步骤：

• 创建一个辅助数组pref[]来存储给定数组的前缀和。
• 计算满足上述方程的子阵列，方程可写为：

(pref[j] − j) % k = (pref[i] − i) % k, where j > i and (j − i) ≤ K

• 遍历前缀数组pref[]并为每个索引j在 Map M 中存储计数(pref[j] – j) % K。
• 对于上述步骤中的每个元素pref[i] ，将计数更新为M[(pref[i] – i % K + K) % K]并增加(pref[i] – i % K + K) %的频率地图M 中的K。
• 完成上述步骤后，打印子数组的计数值。

下面是上述方法的实现：

C++

// C++ program of the above approach
 
#include 
using namespace std;
 
// Function that counts the subarrays
// s.t. sum of elements in the subarray
// modulo k is equal to size of subarray
long long int countSubarrays(
    int a[], int n, int k)
{
    // Stores the count of (pref[i] - i) % k
    unordered_map cnt;
 
    // Stores the count of subarray
    long long int ans = 0;
 
    // Stores prefix sum of the array
    vector pref;
    pref.push_back(0);
 
    // Find prefix sum array
    for (int i = 0; i < n; i++)
        pref.push_back((a[i]
                        + pref[i])
                       % k);
 
    // Base Condition
    cnt[0] = 1;
 
    for (int i = 1; i <= n; i++) {
 
        // Remove the index at present
        // after K indices from the
        // current index
        int remIdx = i - k;
 
        if (remIdx >= 0) {
            cnt[(pref[remIdx]
                 - remIdx % k + k)
                % k]--;
        }
 
        // Update the answer for subarrays
        // ending at the i-th index
        ans += cnt[(pref[i]
                    - i % k + k)
                   % k];
 
        // Add the calculated value of
        // current index to count
        cnt[(pref[i] - i % k + k) % k]++;
    }
 
    // Print the count of subarrays
    cout << ans << ' ';
}
 
// Driver Code
int main()
{
    // Given arr[]
    int arr[] = { 2, 3, 5, 3, 1, 5 };
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Given K
    int K = 4;
 
    // Function Call
    countSubarrays(arr, N, K);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
import java.lang.*;
import java.io.*;
 
class GFG{
     
// Function that counts the subarrays
// having sum modulo k equal to the
// length of subarray
   
static void countSubarrays(int a[], int n,
                                    int k)
{
     
    // Stores the count of (pref[i] - i) % k
    HashMap cnt = new HashMap<>();
   
    // Stores the count of subarray
    long  ans = 0;
     
    // Stores prefix sum of the array
    ArrayList pref = new ArrayList<>();
    pref.add(0);
     
    // Find prefix sum array
    for(int i = 0; i < n; i++)
        pref.add((a[i] + pref.get(i)) % k);
   
    // Base Condition
    cnt.put(0, 1);
   
    for(int i = 1; i <= n; i++)
    {
         
        // Remove the index at present
        // after K indices from the
        // current index
        int remIdx = i - k;
   
        if (remIdx >= 0)
        {
            if (cnt.containsKey((pref.get(remIdx) -
                                   remIdx % k + k) % k))
                cnt.put((pref.get(remIdx) -
                          remIdx % k + k) % k,
                cnt.get((pref.get(remIdx) -
                          remIdx % k + k) % k) - 1);
                 
            else
                cnt.put((pref.get(remIdx) -
                          remIdx % k + k) % k, -1);
        }
   
        // Update the answer for subarrays
        // ending at the i-th index
        if (cnt.containsKey((pref.get(i) -
                              i % k + k) % k))
            ans += cnt.get((pref.get(i) -
                             i % k + k) % k);
   
        // Add the calculated value of
        // current index to count
        if (cnt.containsKey((pref.get(i) -
                           i % k + k) % k))
            cnt.put((pref.get(i) -
                      i % k + k) % k,
            cnt.get((pref.get(i) -
                 i % k + k) % k) + 1);
        else
            cnt.put((pref.get(i) -
                      i % k + k) % k, 1);
    }
   
    // Print the count of subarrays
    System.out.println(ans);
}
   
// Driver Code
public static void main (String[] args)
throws java.lang.Exception
{
     
    // Given arr[]
    int arr[] = { 2, 3, 5, 3, 1, 5 };
     
    // Size of the array
    int N = arr.length;
     
    // Given K
    int K = 4;
     
    // Function call
    countSubarrays(arr, N, K);
}
}
 
// This code is contributed by bikram2001jha

蟒蛇3

# Python3 program of the above approach
 
# Function that counts the subarrays
# s.t. sum of elements in the subarray
# modulo k is equal to size of subarray
def countSubarrays(a, n, k):
 
    # Stores the count of (pref[i] - i) % k
    cnt = {}
  
    # Stores the count of subarray
    ans = 0
  
    # Stores prefix sum of the array
    pref = []
    pref.append(0)
  
    # Find prefix sum array
    for i in range(n):
        pref.append((a[i] + pref[i]) % k)
  
    # Base Condition
    cnt[0] = 1
  
    for i in range(1, n + 1):
     
        # Remove the index at present
        # after K indices from the
        # current index
        remIdx = i - k
  
        if (remIdx >= 0):
            if ((pref[remIdx] -
                   remIdx % k + k) % k in cnt):
                cnt[(pref[remIdx] -
                       remIdx % k + k) % k] -= 1
            else:
                cnt[(pref[remIdx] -
                       remIdx % k + k) % k] = -1
                 
        # Update the answer for subarrays
        # ending at the i-th index
        if (pref[i] - i % k + k) % k in cnt:
            ans += cnt[(pref[i] - i % k + k) % k]
  
        # Add the calculated value of
        # current index to count
        if (pref[i] - i % k + k) % k in cnt:
            cnt[(pref[i] - i % k + k) % k] += 1
        else:
            cnt[(pref[i] - i % k + k) % k] = 1
     
    # Print the count of subarrays
    print(ans, end = ' ')
 
# Driver code 
 
# Given arr[]
arr = [ 2, 3, 5, 3, 1, 5 ]
 
# Size of the array
N = len(arr)
 
# Given K
K = 4
 
# Function call
countSubarrays(arr, N, K)
 
# This code is contributed by divyeshrabadiya07

C＃

// C# program for
// the above approach
using System;
using System.Collections.Generic;
class GFG{
     
// Function that counts the subarrays
// having sum modulo k equal to the
// length of subarray
static void countSubarrays(int []a, int n,
                           int k)
{
  // Stores the count of
  // (pref[i] - i) % k
  Dictionary cnt = new Dictionary();
   
  // Stores the count of subarray
  long ans = 0;
 
  // Stores prefix sum of the array
  List pref = new List();
  pref.Add(0);
 
  // Find prefix sum array
  for(int i = 0; i < n; i++)
    pref.Add((a[i] + pref[i]) % k);
 
  // Base Condition
  cnt.Add(0, 1);
 
  for(int i = 1; i <= n; i++)
  {
    // Remove the index at present
    // after K indices from the
    // current index
    int remIdx = i - k;
 
    if (remIdx >= 0)
    {
      if (cnt.ContainsKey((pref[remIdx] -
                           remIdx % k + k) % k))
        cnt[(pref[remIdx] -
             remIdx % k + k) % k] = cnt[(pref[remIdx] -
                                    remIdx % k + k) % k] - 1;
 
      else
        cnt.Add((pref[remIdx] -
                 remIdx % k + k) % k, -1);
    }
 
    // Update the answer for subarrays
    // ending at the i-th index
    if (cnt.ContainsKey((pref[i] -
                         i % k + k) % k))
      ans += cnt[(pref[i] -
                  i % k + k) % k];
 
    // Add the calculated value of
    // current index to count
    if (cnt.ContainsKey((pref[i] -
                         i % k + k) % k))
      cnt[(pref[i] -
           i % k + k) % k] = cnt[(pref[i] -
                                  i % k + k) % k] + 1;
    else
      cnt.Add((pref[i] -
               i % k + k) % k, 1);
  }
 
  // Print the count of subarrays
  Console.WriteLine(ans);
}
   
// Driver Code
public static void Main(String[] args)
 
{
  // Given []arr
  int []arr = {2, 3, 5, 3, 1, 5};
 
  // Size of the array
  int N = arr.Length;
 
  // Given K
  int K = 4;
 
  // Function call
  countSubarrays(arr, N, K);
}
}
 
// This code is contributed by Rajput-Ji

输出：

5

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

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live