logo

TechCodeview

Numărați Subbarrays cu suma divizibilă cu K

Dată o matrice arr[] și un număr întreg k sarcina este de a număra toate subbariile a căror sumă este divizibil cu k .

Exemple:

Intrare: arr[] = [4 5 0 -2 -3 1] k = 5
Ieșire: 7
Explicaţie: Există 7 subtare a căror sumă este divizibilă cu 5: [4 5 0 -2 -3 1] [5] [5 0] [5 0 -2 -3] [0] [0 -2 -3] și [-2 -3].



mb vs gb

Intrare: arr[] = [2 2 2 2 2 2] k = 2
Ieșire: 21
Explicaţie: Toate sumele secundare sunt divizibile cu 2.

Intrare: arr[] = [-1 -3 2] k = 5
Ieșire:
Explicaţie: Nu există un subbary a cărui sumă să fie divizibilă cu k.

Cuprins

java se agită la int

[Abordare naivă] Repetând peste toate subdiversiunile

Ideea este de a repeta peste toate subbaryurile posibile în timp ce ținem evidența suma subbarray modulo k . Pentru orice subtază, dacă sub-taxa modulo k devine 0, incrementează numărul cu 1. După iterare peste toate sub-tabele, returnează numărul ca rezultat.

C++ 
// C++ Code to Count Subarrays With Sum Divisible By K // by iterating over all possible subarrays #include    #include  using namespace std; int subCount(vector<int> &arr int k) {  int n = arr.size() res = 0;     // Iterating over starting indices of subarray  for(int i = 0; i < n; i++) {  int sum = 0;    // Iterating over ending indices of subarray  for(int j = i; j < n; j++) {  sum = (sum + arr[j]) % k;  if(sum == 0)  res += 1;  }  }  return res; } int main() {  vector<int> arr = {4 5 0 -2 -3 1};  int k = 5;    cout << subCount(arr k); }
C 
// C Code to Count Subarrays With Sum Divisible By K // by iterating over all possible subarrays #include  int subCount(int arr[] int n int k) {  int res = 0;  // Iterating over starting indices of subarray  for (int i = 0; i < n; i++) {  int sum = 0;  // Iterating over ending indices of subarray  for (int j = i; j < n; j++) {  sum = (sum + arr[j]) % k;  if (sum == 0)  res += 1;  }  }  return res; } int main() {  int arr[] = {4 5 0 -2 -3 1};  int k = 5;  int n = sizeof(arr) / sizeof(arr[0]);  printf('%d' subCount(arr n k));  return 0; }
Java 
// Java Code to Count Subarrays With Sum Divisible By K // by iterating over all possible subarrays import java.util.*; class GfG {  static int subCount(int[] arr int k) {  int n = arr.length res = 0;  // Iterating over starting indices of subarray  for (int i = 0; i < n; i++) {  int sum = 0;  // Iterating over ending indices of subarray  for (int j = i; j < n; j++) {  sum = (sum + arr[j]) % k;  if (sum == 0)  res += 1;  }  }  return res;  }  public static void main(String[] args) {  int[] arr = {4 5 0 -2 -3 1};  int k = 5;  System.out.println(subCount(arr k));  } }
Python 
# Python Code to Count Subarrays With Sum Divisible By K # by iterating over all possible subarrays def subCount(arr k): n = len(arr) res = 0 # Iterating over starting indices of subarray for i in range(n): sum = 0 # Iterating over ending indices of subarray for j in range(i n): sum = (sum + arr[j]) % k if sum == 0: res += 1 return res if __name__ == '__main__': arr = [4 5 0 -2 -3 1] k = 5 print(subCount(arr k))
C# 
// C# Code to Count Subarrays With Sum Divisible By K // by iterating over all possible subarrays using System; using System.Collections.Generic; class GfG {   static int subCount(int[] arr int k) {  int n = arr.Length res = 0;  // Iterating over starting indices of subarray  for (int i = 0; i < n; i++) {  int sum = 0;  // Iterating over ending indices of subarray  for (int j = i; j < n; j++) {  sum = (sum + arr[j]) % k;  if (sum == 0)  res += 1;  }  }  return res;  }  static void Main() {  int[] arr = { 4 5 0 -2 -3 1 };  int k = 5;  Console.WriteLine(subCount(arr k));  } }
JavaScript 
// JavaScript Code to Count Subarrays With Sum Divisible By K // by iterating over all possible subarrays function subCount(arr k) {  let n = arr.length res = 0;  // Iterating over starting indices of subarray  for (let i = 0; i < n; i++) {  let sum = 0;  // Iterating over ending indices of subarray  for (let j = i; j < n; j++) {  sum = (sum + arr[j]) % k;  if (sum === 0)  res += 1;  }  }  return res; } // Driver Code let arr = [4 5 0 -2 -3 1]; let k = 5; console.log(subCount(arr k));

Ieșire 
7

Complexitatea timpului: O(n^2) pe măsură ce repetăm ​​peste toate punctele de început și de sfârșit posibile ale subgrupurilor.
Spațiu auxiliar: O(1)

[Abordare așteptată] Folosind Prefix Sum modulo k

Ideea este de a folosi Tehnica sumei prefixelor împreună cu Hashing . Observând cu atenție, putem spune că, dacă o sumă arr[i...j] are suma divizibilă cu k, atunci (prefixul sum[i] % k) va fi egal cu (prefixul sum[j] % k). Deci, putem itera peste arr[] menținând o hartă hash sau un dicționar pentru a număra numărul de (prefix sum mod k). Pentru fiecare index i, numărul de sub-tare care se termină la i și având suma divizibilă cu k va fi egal cu numărul de apariții ale (prefixul sum[i] mod k) înainte de i.

Nota: Valoarea negativă a (prefixul suma mod k) trebuie tratată separat în limbi precum C++ Java C# şi JavaScript întrucât în Piton (prefixul sum mod k) este întotdeauna o valoare nenegativă, deoarece ia semnul divizorului care este k .

metode arraylist
C++ 
// C++ Code to Count Subarrays With Sum Divisible By K // using Prefix Sum and Hash map #include    #include  #include  using namespace std; int subCount(vector<int> &arr int k) {  int n = arr.size() res = 0;  unordered_map<int int> prefCnt;  int sum = 0;    // Iterate over all ending points  for(int i = 0; i < n; i++) {    // prefix sum mod k (handling negative prefix sum)  sum = ((sum + arr[i]) % k + k) % k;    // If sum == 0 then increment the result by 1  // to count subarray arr[0...i]  if(sum == 0)  res += 1;    // Add count of all starting points for index i  res += prefCnt[sum];    prefCnt[sum] += 1;  }  return res; } int main() {  vector<int> arr = {4 5 0 -2 -3 1};  int k = 5;    cout << subCount(arr k); }
Java 
// Java Code to Count Subarrays With Sum Divisible By K // using Prefix Sum and Hash map import java.util.*; class GfG {  static int subCount(int[] arr int k) {  int n = arr.length res = 0;  Map<Integer Integer> prefCnt = new HashMap<>();  int sum = 0;  // Iterate over all ending points  for (int i = 0; i < n; i++) {  // prefix sum mod k (handling negative prefix sum)  sum = ((sum + arr[i]) % k + k) % k;  // If sum == 0 then increment the result by 1  // to count subarray arr[0...i]  if (sum == 0)  res += 1;  // Add count of all starting points for index i  res += prefCnt.getOrDefault(sum 0);  prefCnt.put(sum prefCnt.getOrDefault(sum 0) + 1);  }  return res;  }  public static void main(String[] args) {  int[] arr = {4 5 0 -2 -3 1};  int k = 5;  System.out.println(subCount(arr k));  } }
Python 
# Python Code to Count Subarrays With Sum Divisible By K # using Prefix Sum and Dictionary from collections import defaultdict def subCount(arr k): n = len(arr) res = 0 prefCnt = defaultdict(int) sum = 0 # Iterate over all ending points for i in range(n): sum = (sum + arr[i]) % k # If sum == 0 then increment the result by 1 # to count subarray arr[0...i] if sum == 0: res += 1 # Add count of all starting points for index i res += prefCnt[sum] prefCnt[sum] += 1 return res if __name__ == '__main__': arr = [4 5 0 -2 -3 1] k = 5 print(subCount(arr k))
C# 
// C# Code to Count Subarrays With Sum Divisible By K // using Prefix Sum and Hash map using System; using System.Collections.Generic; class GfG {  static int SubCount(int[] arr int k) {  int n = arr.Length res = 0;  Dictionary<int int> prefCnt = new Dictionary<int int>();  int sum = 0;  // Iterate over all ending points  for (int i = 0; i < n; i++) {    // prefix sum mod k (handling negative prefix sum)  sum = ((sum + arr[i]) % k + k) % k;  // If sum == 0 then increment the result by 1  // to count subarray arr[0...i]  if (sum == 0)  res += 1;  // Add count of all starting points for index i  if (prefCnt.ContainsKey(sum))  res += prefCnt[sum];  if (prefCnt.ContainsKey(sum))  prefCnt[sum] += 1;  else  prefCnt[sum] = 1;  }  return res;  }  static void Main() {  int[] arr = { 4 5 0 -2 -3 1 };  int k = 5;  Console.WriteLine(SubCount(arr k));  } }
JavaScript 
// JavaScript Code to Count Subarrays With Sum Divisible By K // using Prefix Sum and Hash map function subCount(arr k) {  let n = arr.length res = 0;  let prefCnt = new Map();  let sum = 0;  // Iterate over all ending points  for (let i = 0; i < n; i++) {  // prefix sum mod k (handling negative prefix sum)  sum = ((sum + arr[i]) % k + k) % k;  // If sum == 0 then increment the result by 1  // to count subarray arr[0...i]  if (sum === 0)  res += 1;  // Add count of all starting points for index i  res += (prefCnt.get(sum) || 0);  prefCnt.set(sum (prefCnt.get(sum) || 0) + 1);  }  return res; } // Driver Code let arr = [4 5 0 -2 -3 1]; let k = 5; console.log(subCount(arr k));

Ieșire 
7

Complexitatea timpului: O(n) deoarece iterăm peste matrice o singură dată.
Spațiu auxiliar: O(min(n k)) ca cel mult k cheile pot fi prezente în harta hash sau în dicționar.


Creați un test