Maximize count of non-overlapping subarrays with sum K
Last Updated :
11 Jul, 2022
Given an array arr[] and an integer K, the task is to print the maximum number of non-overlapping subarrays with a sum equal to K.
Examples:
Input: arr[] = {-2, 6, 6, 3, 5, 4, 1, 2, 8}, K = 10
Output: 3
Explanation: All possible non-overlapping subarrays with sum K(= 10) are {-2, 6, 6}, {5, 4, 1}, {2, 8}. Therefore, the required count is 3.
Input: arr[] = {1, 1, 1}, K = 2
Output: 1
Approach: The problem can be solved using the concept of prefix sum. Follow the below steps to solve the problem:
- Initialize a set to store all the prefix sums obtained up to the current element.
- Initialize variables prefixSum and res, to store the prefix sum of the current subarray and the count of subarrays with a sum equal to K respectively.
- Iterate over the array and for each array element, update prefixSum by adding to it the current element. Now, check if the value prefixSum - K is already present in the set or not. If found to be true, increment res, clear the set, and reset the value of prefixSum.
- Repeat the above steps until the entire array is traversed. Finally, print the value of res.
C++14
// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to count the maximum
// number of subarrays with sum K
int CtSubarr(int arr[], int N, int K)
{
// Stores all the distinct
// prefixSums obtained
unordered_set<int> st;
// Stores the prefix sum
// of the current subarray
int prefixSum = 0;
st.insert(prefixSum);
// Stores the count of
// subarrays with sum K
int res = 0;
for (int i = 0; i < N; i++) {
prefixSum += arr[i];
// If a subarray with sum K
// is already found
if (st.count(prefixSum - K)) {
// Increase count
res += 1;
// Reset prefix sum
prefixSum = 0;
// Clear the set
st.clear();
st.insert(0);
}
// Insert the prefix sum
st.insert(prefixSum);
}
return res;
}
// Driver Code
int main()
{
int arr[] = { -2, 6, 6, 3, 5, 4, 1, 2, 8 };
int N = sizeof(arr) / sizeof(arr[0]);
int K = 10;
cout << CtSubarr(arr, N, K);
}
// Java Program to implement
// the above approach
import java.util.*;
class GFG{
// Function to count the maximum
// number of subarrays with sum K
static int CtSubarr(int[] arr,
int N, int K)
{
// Stores all the distinct
// prefixSums obtained
Set<Integer> st = new HashSet<Integer>();
// Stores the prefix sum
// of the current subarray
int prefixSum = 0;
st.add(prefixSum);
// Stores the count of
// subarrays with sum K
int res = 0;
for (int i = 0; i < N; i++)
{
prefixSum += arr[i];
// If a subarray with sum K
// is already found
if (st.contains(prefixSum - K))
{
// Increase count
res += 1;
// Reset prefix sum
prefixSum = 0;
// Clear the set
st.clear();
st.add(0);
}
// Insert the prefix sum
st.add(prefixSum);
}
return res;
}
// Driver Code
public static void main(String[] args)
{
int arr[] = {-2, 6, 6, 3,
5, 4, 1, 2, 8};
int N = arr.length;
int K = 10;
System.out.println(CtSubarr(arr, N, K));
}
}
// This code is contributed by Chitranayal
# Python3 program to implement
# the above approach
# Function to count the maximum
# number of subarrays with sum K
def CtSubarr(arr, N, K):
# Stores all the distinct
# prefixSums obtained
st = set()
# Stores the prefix sum
# of the current subarray
prefixSum = 0
st.add(prefixSum)
# Stores the count of
# subarrays with sum K
res = 0
for i in range(N):
prefixSum += arr[i]
# If a subarray with sum K
# is already found
if((prefixSum - K) in st):
# Increase count
res += 1
# Reset prefix sum
prefixSum = 0
# Clear the set
st.clear()
st.add(0)
# Insert the prefix sum
st.add(prefixSum)
return res
# Driver Code
arr = [ -2, 6, 6, 3, 5, 4, 1, 2, 8 ]
N = len(arr)
K = 10
# Function call
print(CtSubarr(arr, N, K))
# This code is contributed by Shivam Singh
// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG{
// Function to count the maximum
// number of subarrays with sum K
static int CtSubarr(int[] arr,
int N, int K)
{
// Stores all the distinct
// prefixSums obtained
HashSet<int> st = new HashSet<int>();
// Stores the prefix sum
// of the current subarray
int prefixSum = 0;
st.Add(prefixSum);
// Stores the count of
// subarrays with sum K
int res = 0;
for(int i = 0; i < N; i++)
{
prefixSum += arr[i];
// If a subarray with sum K
// is already found
if (st.Contains(prefixSum - K))
{
// Increase count
res += 1;
// Reset prefix sum
prefixSum = 0;
// Clear the set
st.Clear();
st.Add(0);
}
// Insert the prefix sum
st.Add(prefixSum);
}
return res;
}
// Driver Code
public static void Main(String[] args)
{
int []arr = { -2, 6, 6, 3,
5, 4, 1, 2, 8};
int N = arr.Length;
int K = 10;
Console.WriteLine(CtSubarr(arr, N, K));
}
}
// This code is contributed by 29AjayKumar
<script>
// Javascript Program to implement
// the above approach
// Function to count the maximum
// number of subarrays with sum K
function CtSubarr(arr, N, K)
{
// Stores all the distinct
// prefixSums obtained
var st = new Set();
// Stores the prefix sum
// of the current subarray
var prefixSum = 0;
st.add(prefixSum);
// Stores the count of
// subarrays with sum K
var res = 0;
for (var i = 0; i < N; i++) {
prefixSum += arr[i];
// If a subarray with sum K
// is already found
if (st.has(prefixSum - K)) {
// Increase count
res += 1;
// Reset prefix sum
prefixSum = 0;
// Clear the set
st = new Set();
st.add(0);
}
// Insert the prefix sum
st.add(prefixSum);
}
return res;
}
// Driver Code
var arr = [-2, 6, 6, 3, 5, 4, 1, 2, 8];
var N = arr.length;
var K = 10;
document.write( CtSubarr(arr, N, K));
// This code is contributed by importantly.
</script>
Time Complexity: O(N)
Auxiliary Space: O(N)
Related Topic: Subarrays, Subsequences, and Subsets in Array
Similar Reads
Count maximum non-overlapping subarrays with given sum 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 = 6Output: 3Expla
7 min read
Maximum sum of at most K non-overlapping Subarray Given an array, arr[] of size N, the task is to find the sum of the at most K non-overlapping contiguous subarray within an arr[] with the maximum sum. Examples: Input: arr[] = [4, 1, -3, 7, -5, 6, -2, 1], K = 3Output: 18Explanation: In the above input, the maximum k subarray sum is 18 and the subar
15 min read
Maximum sum two non-overlapping subarrays of given size Given an array, we need to find two subarrays with a specific length K such that sum of these subarrays is maximum among all possible choices of subarrays. Examples: Input : arr[] = [2, 5, 1, 2, 7, 3, 0] K = 2 Output : 2 5 7 3 We can choose two arrays of maximum sum as [2, 5] and [7, 3], the sum of
12 min read
Maximum Sum of two non-overlapping Subarrays of any length Given an array A consisting of N integers, the task is to find the maximum sum of two non-overlapping subarrays of any length of the array. Note: You can select empty subarrays also. Examples: Input: N = 3, A[] = {-4, -5, -2}Output: 0Explanation: Two empty subarrays are optimal with maximum sum = 0.
6 min read
Maximum sum of non-overlapping subarrays of length atmost K Given an integer array 'arr' of length N and an integer 'k', select some non-overlapping subarrays such that each sub-array if of length at most 'k', no two sub-arrays are adjacent and sum of all the elements of the selected sub-arrays are maximum.Examples: Input : arr[] = {-1, 2, -3, 4, 5}, k = 2 O
10 min read