Count subarrays with non-zero sum in the given Array

0 0 5 minutes read

Given an array arr[] of size N, the task is to count the total number of subarrays for the given array arr[] which have a non-zero-sum.
Examples:

Input: arr[] = {-2, 2, -3}
Output: 4
Explanation:
The subarrays with non zero sum are: [-2], [2], [2, -3], [-3]. All possible subarray of the given input array are [-2], [2], [-3], [2, -2], [2, -3], [-2, 2, -3]. Out of these [2, -2] is not included in the count because 2+(-2) = 0 and [-2, 2, -3] is not selected because one the subarray [2, -2] of this array has a zero sum of elements.
Input: arr[] = {1, 3, -2, 4, -1}
Output: 15
Explanation:
There are 15 subarray for the given array {1, 3, -2, 4, -1} which has a non zero sum.

Approach:
The main idea to solve the above question is to use the Prefix Sum Array and Map Data Structure.

First, build the Prefix sum array of the given array and use the below formula to check if the subarray has 0 sum of elements.

Sum of Subarray[L, R] = Prefix[R] – Prefix[L – 1]. So, If Sum of Subarray[L, R] = 0
Then, Prefix[R] – Prefix[L – 1] = 0. Hence, Prefix[R] = Prefix[L – 1]

Now, iterate from 1 to N and keep a Hash table for storing the index of the previous occurrence of the element and a variable let’s say last, and initialize it to 0.
Check if Prefix[i] is already present in the Hash or not. If yes then, update last as last = max(last, hash[Prefix[i]] + 1). Otherwise, Add i – last to the answer and update the Hash table.

Below is the implementation of the above approach:

C++

// C++ program to Count the total number of 
// subarrays for a given array such that its 
// subarray should have non zero sum
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to build the Prefix sum array
vector<int> PrefixSumArray(int arr[], int n)
{
    vector<int> prefix(n);
 
    // Store prefix of the first position
    prefix[0] = arr[0];
 
    for (int i = 1; i < n; i++)
        prefix[i] = prefix[i - 1] + arr[i];
 
    return prefix;
}
 
// Function to return the Count of
// the total number of subarrays
int CountSubarray(int arr[], int n)
{
    vector<int> Prefix(n);
 
    // Calculating the prefix array
    Prefix = PrefixSumArray(arr, n);
 
    int last = 0, ans = 0;
 
    map<int, int> Hash;
 
    Hash[0] = -1;
 
    for (int i = 0; i <= n; i++) {
        // Check if the element already exists
        if (Hash.count(Prefix[i]))
            last = max(last, Hash[Prefix[i]] + 1);
 
        ans += max(0, i - last);
 
        // Mark the element
        Hash[Prefix[i]] = i;
    }
 
    // Return the final answer
    return ans;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 3, -2, 4, -1 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    cout << CountSubarray(arr, N);
}

Java

// Java program to count the total number of 
// subarrays for a given array such that its 
// subarray should have non zero sum
import java.util.*;
 
class GFG{
 
// Function to build the Prefix sum array
static int[] PrefixSumArray(int arr[], int n)
{
    int []prefix = new int[n];
     
    // Store prefix of the first position
    prefix[0] = arr[0];
 
    for(int i = 1; i < n; i++)
        prefix[i] = prefix[i - 1] + arr[i];
 
    return prefix;
}
 
// Function to return the Count of
// the total number of subarrays
static int CountSubarray(int arr[], int n)
{
    int []Prefix = new int[n];
 
    // Calculating the prefix array
    Prefix = PrefixSumArray(arr, n);
 
    int last = 0, ans = 0;
 
    HashMap<Integer,
            Integer> Hash = new HashMap<Integer,
                                        Integer>();
 
    Hash.put(0, -1);
 
    for(int i = 0; i <= n; i++) 
    {
         
        // Check if the element already exists
        if (i < n && Hash.containsKey(Prefix[i]))
            last = Math.max(last, 
                            Hash.get(Prefix[i]) + 1);
 
        ans += Math.max(0, i - last);
 
        // Mark the element
        if (i < n)
        Hash.put(Prefix[i], i);
    }
 
    // Return the final answer
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 3, -2, 4, -1 };
 
    int N = arr.length;
 
    System.out.print(CountSubarray(arr, N));
}
}
 
// This code is contributed by amal kumar choubey

Python3

# Python3 program to count the total number  
# of subarrays for a given array such that 
# its subarray should have non zero sum 
 
# Function to build the prefix sum array 
def PrefixSumArray(arr, n):
 
    prefix = [0] * (n + 1); 
 
    # Store prefix of the first position 
    prefix[0] = arr[0]; 
 
    for i in range(1, n):
        prefix[i] = prefix[i - 1] + arr[i]; 
         
    return prefix; 
 
# Function to return the count of 
# the total number of subarrays 
def CountSubarray(arr, n): 
 
    Prefix = [0] * (n + 1); 
 
    # Calculating the prefix array 
    Prefix = PrefixSumArray(arr, n); 
 
    last = 0; ans = 0; 
 
    Hash = {}; 
 
    Hash[0] = -1; 
 
    for i in range(n + 1):
         
        # Check if the element already exists 
        if (Prefix[i] in Hash):
            last = max(last, Hash[Prefix[i]] + 1); 
 
        ans += max(0, i - last); 
 
        # Mark the element 
        Hash[Prefix[i]] = i; 
 
    # Return the final answer 
    return ans; 
 
# Driver code 
if __name__ == "__main__" : 
 
    arr = [ 1, 3, -2, 4, -1 ]; 
    N = len(arr); 
 
    print(CountSubarray(arr, N)); 
     
# This code is contributed by AnkitRai01

C#

// C# program to count the total number of 
// subarrays for a given array such that its 
// subarray should have non zero sum
using System;
using System.Collections.Generic;
class GFG{
 
// Function to build the Prefix sum array
static int[] PrefixSumArray(int []arr, int n)
{
    int []prefix = new int[n];
     
    // Store prefix of the first position
    prefix[0] = arr[0];
 
    for(int i = 1; i < n; i++)
        prefix[i] = prefix[i - 1] + arr[i];
    return prefix;
}
 
// Function to return the Count of
// the total number of subarrays
static int CountSubarray(int []arr, int n)
{
    int []Prefix = new int[n];
 
    // Calculating the prefix array
    Prefix = PrefixSumArray(arr, n);
 
    int last = 0, ans = 0;
    Dictionary<int,
               int> Hash = new Dictionary<int,
                                          int>();
    Hash.Add(0, -1);
    for(int i = 0; i <= n; i++) 
    {        
        // Check if the element already exists
        if (i < n && Hash.ContainsKey(Prefix[i]))
            last = Math.Max(last, 
                            Hash[Prefix[i]] + 1);
 
        ans += Math.Max(0, i - last);
 
        // Mark the element
        if (i < n)
        Hash.Add(Prefix[i], i);
    }
 
    // Return the readonly answer
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    int []arr = {1, 3, -2, 4, -1};
    int N = arr.Length;
    Console.Write(CountSubarray(arr, N));
}
}
 
// This code is contributed by shikhasingrajput

Javascript

<script>
 
// Javascript program to count the total number of
// subarrays for a given array such that its
// subarray should have non zero sum
 
// Function to build the Prefix sum array
function PrefixSumArray(arr, n)
{
    let prefix = Array.from({length: n}, (_, i) => 0);
      
    // Store prefix of the first position
    prefix[0] = arr[0];
  
    for(let i = 1; i < n; i++)
        prefix[i] = prefix[i - 1] + arr[i];
  
    return prefix;
}
  
// Function to return the Count of
// the total number of subarrays
function CountSubarray(arr, n)
{
    let Prefix = Array.from({length: n}, (_, i) => 0);
  
    // Calculating the prefix array
    Prefix = PrefixSumArray(arr, n);
  
    let last = 0, ans = 0;
  
    let Hash = new Map();
  
    Hash.set(0, -1);
  
    for(let i = 0; i <= n; i++)
    {
          
        // Check if the element already exists
        if (i < n && Hash.has(Prefix[i]))
            last = Math.max(last,
                            Hash.get(Prefix[i]) + 1);
  
        ans += Math.max(0, i - last);
  
        // Mark the element
        if (i < n)
        Hash.set(Prefix[i], i);
    }
  
    // Return the final answer
    return ans;
}
 
// Driver code
     
      let arr = [ 1, 3, -2, 4, -1 ];
  
    let N = arr.length;
  
    document.write(CountSubarray(arr, N));
  
 // This code is contributed by code_hunt.
</script>

Output:

Time Complexity: O(N)
Auxiliary Space: O(N)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!