Zero Sum Subarrays Count 🎯

Welcome to our comprehensive guide on the Zero Sum Subarrays Count problem! This tutorial is designed to help both beginners and intermediate learners understand and solve this interesting problem. Let's dive in!

Understanding the Problem

The Zero Sum Subarrays Count problem is a classic algorithmic problem that asks to find the number of contiguous subarrays within an array that have a sum equal to zero. 📝

Breaking it Down

Let's break down the problem step-by-step:

Input: An array of integers arr[].
Output: The count of subarrays with a sum equal to zero.
Constraints: The time complexity should be as optimal as possible, preferably linear (O(n)).

Solution Approach

We will approach this problem by using a prefix sum approach, which helps us to efficiently calculate the sum of subarrays. 💡

Prefix Sum Concept

The prefix sum technique involves calculating the sum of elements from the start of the array to a specific index. For an array arr[] and an index i, the prefix sum is calculated as prefixSum[i] = arr[0] + arr[1] + ... + arr[i-1]. This allows us to quickly find the sum of a subarray by subtracting the prefix sum of the starting index from the prefix sum of the ending index.

Algorithm

Here's a simple algorithm to solve the Zero Sum Subarrays Count problem using the prefix sum approach:

Initialize an empty list prefixSum to store the prefix sums of the array.
Iterate through the array and calculate the prefix sum for each index, storing the result in prefixSum.
Initialize a variable zeroSumCount to store the count of subarrays with a sum equal to zero.
Initialize two pointers, start and end, to the beginning of the array.
Iterate through the array using the pointers:
- Calculate the sum of elements from start to end using the prefix sum approach.
- If the sum is zero, increment zeroSumCount and move the start pointer to the right.
- Move the end pointer to the right.
Return the value of zeroSumCount.

Code Examples

Python

python

def find_zero_sum_subarrays(arr):
    prefix_sum = [0] * len(arr)
    zero_sum_count = 0

    prefix_sum[0] = arr[0]
    for i in range(1, len(arr)):
        prefix_sum[i] = prefix_sum[i - 1] + arr[i]

    start, end = 0, 0
    while end < len(arr):
        if prefix_sum[end] - prefix_sum[start] == 0:
            zero_sum_count += 1
            start += 1

        end += 1

    return zero_sum_count

Java

java

public int findZeroSumSubarrays(int[] arr) {
    int[] prefixSum = new int[arr.length];
    int zeroSumCount = 0;

    prefixSum[0] = arr[0];
    for (int i = 1; i < arr.length; i++) {
        prefixSum[i] = prefixSum[i - 1] + arr[i];
    }

    int start = 0, end = 0;
    while (end < arr.length) {
        if (prefixSum[end] - prefixSum[start] == 0) {
            zeroSumCount++;
            start++;
        }
        end++;
    }

    return zeroSumCount;
}