Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Maximum count of distinct sized subarrays with given sum

Given a binary array arr[] of N integers, the task is to find the maximum count of distinct sized subarrays such that the sum of each subarray is K.

Example:



Input: arr[] = {0, 1, 1 , 0}, K = 2
Output: 3
Explanation: The subset {{0, 1, 1, 0}, {0, 1, 1}, {1, 1}} is the subset of 3 subarrays such that the sum of each subarray is 2 and the size of each subarray is distinct. The subarray {1, 1, 0} also has sum 2 but a subarray of size 3 is already included.

Input: arr[] = {0, 1, 0, 0, 0, 1 , 0}, K = 1
Output: 5



 

Approach: The given problem can be solved with the help of the sliding window algorithm. It can be observed that the sum of a subarray is equal to the count of 1’s in the subarray. Below are the steps to follow:

Below is the implementation of the above approach:




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find size of the largest
// subset of subarrays having given sum
// and size of each subarray is distinct
int maxSubsetSize(int arr[], int N, int K)
{
    // Stores starting index
    // of the current window
    int ptr = 0;
 
    // Stores distinct subarray
    // sizes of the subset
    unordered_set<int> s;
 
    // Stores the sum of
    // current window
    int curSum = 0;
 
    // Loop to traverse over array
    for (int i = 0; i < N; i++) {
 
        // Update current window sum
        curSum += arr[i];
 
        // If sum is less that K
        if (curSum < K) {
            continue;
        }
 
        // If sum is more than K
        if (curSum > K) {
 
            // Decrease window size
            while (curSum > K) {
                curSum -= arr[ptr++];
            }
        }
 
        if (curSum == K) {
 
            // Insert size of the
            // current window
            s.insert(i - ptr + 1);
            int t = ptr;
 
            // Iterate over all windows
            // with same sum
            while (arr[t] == 0) {
                s.insert(i - t);
                t++;
            }
        }
    }
 
    // Return Answer
    return s.size();
}
 
// Driver Code
int main()
{
    int arr[] = { 0, 1, 1, 0 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 2;
 
    cout << maxSubsetSize(arr, N, K);
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java program for the above approach



import java.util.HashSet;



 



class GFG {



 



  // Function to find size of the largest




  // subset of subarrays having given sum




  // and size of each subarray is distinct




  static int maxSubsetSize(int arr[], int N, int K) {




    // Stores starting index




    // of the current window




    int ptr = 0;



 



    // Stores distinct subarray




    // sizes of the subset




    HashSet<Integer> s = new HashSet<Integer>();



 



    // Stores the sum of




    // current window




    int curSum = 0;



 



    // Loop to traverse over array




    for (int i = 0; i < N; i++) {



 



      // Update current window sum




      curSum += arr[i];



 



      // If sum is less that K




      if (curSum < K) {




        continue;




      }



 



      // If sum is more than K




      if (curSum > K) {



 



        // Decrease window size




        while (curSum > K) {




          curSum -= arr[ptr++];




        }




      }



 



      if (curSum == K) {



 



        // Insert size of the




        // current window




        s.add(i - ptr + 1);




        int t = ptr;



 



        // Iterate over all windows




        // with same sum




        while (arr[t] == 0) {




          s.add(i - t);




          t++;




        }




      }




    }



 



    // Return Answer




    return s.size();




  }



 



  // Driver Code




  public static void main(String args[]) {




    int arr[] = { 0, 1, 1, 0 };




    int N = arr.length;




    int K = 2;



 



    System.out.println(maxSubsetSize(arr, N, K));




  }



}


 


// This code is contributed by saurabh_jaiswal.


















                        






                        























                                    



                                    




                                    




                                    


                                



















# python3 program for the above approach


 


# Function to find size of the largest


# subset of subarrays having given sum


# and size of each subarray is distinct



def maxSubsetSize(arr, N, K):



 



        # Stores starting index




        # of the current window




    ptr = 0



 



    # Stores distinct subarray




    # sizes of the subset




    s = set()



 



    # Stores the sum of




    # current window




    curSum = 0



 



    # Loop to traverse over array




    for i in range(0, N):



 



                # Update current window sum




        curSum += arr[i]



 



        # If sum is less that K




        if (curSum < K):




            continue



 



            # If sum is more than K




        if (curSum > K):



 



                        # Decrease window size




            while (curSum > K):




                curSum -= arr[ptr]




                ptr += 1



 



        if (curSum == K):



 



                        # Insert size of the




                        # current window




            s.add(i - ptr + 1)




            t = ptr



 



            # Iterate over all windows




            # with same sum




            while (arr[t] == 0):




                s.add(i - t)




                t += 1



 



        # Return Answer




    return len(list(s))



 


# Driver Code



if __name__ == "__main__":



 



    arr = [0, 1, 1, 0]




    N = len(arr)




    K = 2



 



    print(maxSubsetSize(arr, N, K))



 



    # This code is contributed by rakeshsahni



















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# program for the above approach



using System;




using System.Collections.Generic;



 



public class GFG {



 



  // Function to find size of the largest




  // subset of subarrays having given sum




  // and size of each subarray is distinct




  static int maxSubsetSize(int []arr, int N, int K)




  {



 



    // Stores starting index




    // of the current window




    int ptr = 0;



 



    // Stores distinct subarray




    // sizes of the subset




    HashSet<int> s = new HashSet<int>();



 



    // Stores the sum of




    // current window




    int curSum = 0;



 



    // Loop to traverse over array




    for (int i = 0; i < N; i++) {



 



      // Update current window sum




      curSum += arr[i];



 



      // If sum is less that K




      if (curSum < K) {




        continue;




      }



 



      // If sum is more than K




      if (curSum > K) {



 



        // Decrease window size




        while (curSum > K) {




          curSum -= arr[ptr++];




        }




      }



 



      if (curSum == K) {



 



        // Insert size of the




        // current window




        s.Add(i - ptr + 1);




        int t = ptr;



 



        // Iterate over all windows




        // with same sum




        while (arr[t] == 0) {




          s.Add(i - t);




          t++;




        }




      }




    }



 



    // Return Answer




    return s.Count;




  }



 



  // Driver Code




  public static void Main(String []args) {




    int []arr = { 0, 1, 1, 0 };




    int N = arr.Length;




    int K = 2;



 



    Console.WriteLine(maxSubsetSize(arr, N, K));




  }



}


 


// This code is contributed by shikhasingrajput


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>



      // JavaScript code for the above approach



 



      // Function to find size of the largest




      // subset of subarrays having given sum




      // and size of each subarray is distinct




      function maxSubsetSize(arr, N, K) {




          // Stores starting index




          // of the current window




          let ptr = 0;



 



          // Stores distinct subarray




          // sizes of the subset




          let s = new Set();



 



          // Stores the sum of




          // current window




          let curSum = 0;



 



          // Loop to traverse over array




          for (let i = 0; i < N; i++) {



 



              // Update current window sum




              curSum += arr[i];



 



              // If sum is less that K




              if (curSum < K) {




                  continue;




              }



 



              // If sum is more than K




              if (curSum > K) {



 



                  // Decrease window size




                  while (curSum > K) {




                      curSum -= arr[ptr++];




                  }




              }



 



              if (curSum == K) {



 



                  // Insert size of the




                  // current window




                  s.add(i - ptr + 1);




                  let t = ptr;



 



                  // Iterate over all windows




                  // with same sum




                  while (arr[t] == 0) {




                      s.add(i - t);




                      t++;




                  }




              }




          }



 



          // Return Answer




          return s.size;




      }



 



      // Driver Code



 



      let arr = [0, 1, 1, 0];




      let N = arr.length;




      let K = 2;



 



      document.write(maxSubsetSize(arr, N, K));



// This code is contributed by Potta Lokesh



  </script>



















                        






                        







 
 

Output

3


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

	

        Article Tags : 
        

            Arrays
DSA
Mathematical
Strings        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Differences between number of increasing subarrays and decreasing subarrays in k sized windows

          
2. Construct N sized Array such that every K sized Subarray has MEX value D

          
3. Maximize the sum of maximum elements of at least K-sized subarrays

          
4. Split given arrays into subarrays to maximize the sum of maximum and minimum in each subarrays

          
5. Number of ways to select equal sized subarrays from two arrays having atleast K equal pairs of elements

          
6. Split array into K subarrays such that sum of maximum of all subarrays is maximized

          
7. Split into K subarrays to minimize the maximum sum of all subarrays

          
8. Maximum sum of even indexed elements obtained by right shift on an even sized subarray

          
9. Maximum given sized rectangles that can be cut out of a sheet of paper

          
10. Maximum multiple of D from K-sized subset sums from given Array

          
11. Maximum sum of subarrays having distinct elements of length K

          
12. Maximize the difference of sum of elements at even indices and odd indices by shifting an odd sized subarray to end of given Array.

          
13. Count subarrays having a single distinct element that can be obtained from a given array

          
14. Maximum sum of K-length subarray with maximum count of distinct prime factors

          
15. Count maximum non-overlapping subarrays with given sum

          
16. Divide Matrix into K groups of adjacent cells having minimum difference between maximum and minimum sized groups

          
17. Count numbers whose maximum sum of distinct digit-sum is less than or equals M

          
18. Maximum XOR value of maximum and second maximum element among all possible subarrays

          
19. Split array into maximum subarrays such that every distinct element lies in a single subarray

          
20. Count of largest sized groups while grouping according to product of digits

          
21. Count of 3 sized Strings of all same or different characters using total X 0s, Y 1s and Z 2s

          
22. Count ways to form N sized Strings with at most two adjacent different pair

          
23. Count ways to select two N sized Substrings differing by one letter

          
24. Maximize sum of each element raised to power of its frequency in K sized subarray

          
25. Maximize total set bits of elements in N sized Array with sum M