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