Count maximum non-overlapping subarrays with given sum
Last Updated :
24 May, 2021
Given an array arr[] consisting of N integers and an integer target, the task is to find the maximum number of non-empty non-overlapping subarrays such that the sum of array elements in each subarray is equal to the target.
Examples:
Input: arr[] = {2, -1, 4, 3, 6, 4, 5, 1}, target = 6
Output: 3
Explanation:
Subarrays {-1, 4, 3}, {6} and {5, 1} have sum equal to target(= 6).
Input: arr[] = {2, 2, 2, 2, 2}, target = 4
Output: 2
Approach: To obtain the smallest non-overlapping subarrays with the sum target, the target is to use the Prefix Sum technique. Follow the steps below to solve the problem:
- Store all the sums calculated so far in a Map mp with key as the sum of the prefix till that index and value as the ending index of the subarray with that sum.
- If the prefix-sum till index i, say sum, is equal to target, check if sum – target exists in the Map or not.
- If sum – target exists in Map and mp[sum – target] = idx, it means that the subarray from [idx + 1, i] has sum equal to target.
- Now for non-overlapping subarrays, maintain an additional variable availIdx(initially set to -1), and take the subarray from [idx + 1, i] only when mp[sum – target] ? availIdx.
- Whenever such a subarray is found, increment the answer and change the value of availIdx to the current index.
- Also, for non-overlapping subarrays, it is always beneficial to greedily take subarrays as small as possible. So, for every prefix-sum found, update its index in the Map, even if it already exists.
- Print the value of count after completing the above steps.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int maximumSubarrays( int arr[], int N,
int target)
{
int ans = 0;
int availIdx = -1;
int cur_sum = 0;
unordered_map< int , int > mp;
mp[0] = -1;
for ( int i = 0; i < N; i++) {
cur_sum += arr[i];
if (mp.find(cur_sum - target)
!= mp.end()
&& mp[cur_sum - target]
>= availIdx) {
ans++;
availIdx = i;
}
mp[cur_sum] = i;
}
return ans;
}
int main()
{
int arr[] = { 2, -1, 4, 3,
6, 4, 5, 1 };
int N = sizeof (arr) / sizeof (arr[0]);
int target = 6;
cout << maximumSubarrays(arr, N,
target);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int maximumSubarrays( int arr[], int N,
int target)
{
int ans = 0 ;
int availIdx = - 1 ;
int cur_sum = 0 ;
HashMap<Integer,
Integer> mp = new HashMap<Integer,
Integer>();
mp.put( 0 , 1 );
for ( int i = 0 ; i < N; i++)
{
cur_sum += arr[i];
if (mp.containsKey(cur_sum - target) &&
mp.get(cur_sum - target) >= availIdx)
{
ans++;
availIdx = i;
}
mp.put(cur_sum, i);
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 2 , - 1 , 4 , 3 ,
6 , 4 , 5 , 1 };
int N = arr.length;
int target = 6 ;
System.out.print(maximumSubarrays(arr, N,
target));
}
}
|
Python3
def maximumSubarrays(arr, N, target):
ans = 0
availIdx = - 1
cur_sum = 0
mp = {}
mp[ 0 ] = - 1
for i in range (N):
cur_sum + = arr[i]
if ((cur_sum - target) in mp and
mp[cur_sum - target] > = availIdx):
ans + = 1
availIdx = i
mp[cur_sum] = i
return ans
if __name__ = = '__main__' :
arr = [ 2 , - 1 , 4 , 3 ,
6 , 4 , 5 , 1 ]
N = len (arr)
target = 6
print (maximumSubarrays(arr, N, target))
|
C#
using System;
using System.Collections.Generic;
class GFG{
static int maximumSubarrays( int []arr, int N,
int target)
{
int ans = 0;
int availIdx = -1;
int cur_sum = 0;
Dictionary< int ,
int > mp = new Dictionary< int ,
int >();
mp.Add(0, 1);
for ( int i = 0; i < N; i++)
{
cur_sum += arr[i];
if (mp.ContainsKey(cur_sum - target) &&
mp[cur_sum - target] >= availIdx)
{
ans++;
availIdx = i;
}
if (mp.ContainsKey(cur_sum))
mp[cur_sum] = i;
else
mp.Add(cur_sum, i);
}
return ans;
}
public static void Main(String[] args)
{
int []arr = {2, -1, 4, 3,
6, 4, 5, 1};
int N = arr.Length;
int target = 6;
Console.Write(maximumSubarrays(arr, N,
target));
}
}
|
Javascript
<script>
function maximumSubarrays(arr, N, target)
{
var ans = 0;
var availIdx = -1;
var cur_sum = 0;
var mp = new Map();
mp.set(0, 1);
for ( var i = 0; i < N; i++) {
cur_sum += arr[i];
if (mp.has(cur_sum - target)
&& mp.get(cur_sum - target)
>= availIdx) {
ans++;
availIdx = i;
}
mp.set(cur_sum , i);
}
return ans;
}
var arr = [2, -1, 4, 3,
6, 4, 5, 1];
var N = arr.length;
var target = 6;
document.write( maximumSubarrays(arr, N,
target));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...