Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Maximize count of subsets into which the given array can be split such that it satisfies the given condition

  • Last Updated : 08 Sep, 2021

Given an array arr[] of size N and a positive integer X, the task is to partition the array into the maximum number of subsets such that the multiplication of the smallest element of each subset with the count of elements in the subsets is greater than or equal to K. Print the maximum count of such subsets possible.

Examples:

Input: arr[] = {1, 3, 3, 7}, X = 3
Output: 3
Explanation: Partition the array into 3 subsets { {1, 3}, {3}, {7} }. Therefore, the required output is 3.

Input: arr[] = {2, 4, 2, 5, 1}, X = 2
Output: 4

Approach: The problem can be solved using the Greedy technique. Follow the steps below to solve the problem:

  • Sort the array elements in decreasing order.
  • Traverse the array and keep track of the size of the current subset
  • As the array is sorted in decreasing order, the rightmost element of the subset will be the smallest element of the current division.
  • So, if (size of current subset * current element) is greater than or equal to X, then increment the count and reset the size of the current partition to 0.
  • Finally, print the count obtained.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count maximum subsets into
// which the given array can be split such
// that it satisfies the given condition
void maxDivisions(int arr[], int N, int X)
{
 
    // Sort the array in decreasing order
    sort(arr, arr + N, greater<int>());
 
    // Stores count of subsets possible
    int maxSub = 0;
 
    // Stores count of elements
    // in current subset
    int size = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++) {
 
        // Update size
        size++;
 
        // If product of the smallest element
        // present in the current subset and
        // size of current subset is >= K
        if (arr[i] * size >= X) {
 
            // Update maxSub
            maxSub++;
 
            // Update size
            size = 0;
        }
    }
 
    cout << maxSub << endl;
}
 
// Driver Code
int main()
{
 
    // Given array
    int arr[] = { 1, 3, 3, 7 };
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Given value of X
    int X = 3;
 
    maxDivisions(arr, N, X);
 
    return 0;
}
Java



// Java program for the above approach
import java.util.*;
class GFG
{
 
// Function to count maximum subsets into
// which the given array can be split such
// that it satisfies the given condition
static void maxDivisions(Integer arr[], int N, int X)
{
 
    // Sort the array in decreasing order
    Arrays.sort(arr,Collections.reverseOrder());
 
    // Stores count of subsets possible
    int maxSub = 0;
 
    // Stores count of elements
    // in current subset
    int size = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++)
    {
 
        // Update size
        size++;
 
        // If product of the smallest element
        // present in the current subset and
        // size of current subset is >= K
        if (arr[i] * size >= X)
        {
 
            // Update maxSub
            maxSub++;
 
            // Update size
            size = 0;
        }
    }
    System.out.print(maxSub +"\n");
}
 
// Driver Code
public static void main(String[] args)
{
 
    // Given array
    Integer arr[] = { 1, 3, 3, 7 };
 
    // Size of the array
    int N = arr.length;
 
    // Given value of X
    int X = 3;
    maxDivisions(arr, N, X);
 
}
}
 
// This code is contributed by shikhasingrajput
Python3



# Python3 program for the above approach
 
# Function to count maximum subsets into
# which the given array can be split such
# that it satisfies the given condition
def maxDivisions(arr, N, X) :
 
    # Sort the array in decreasing order
    arr.sort(reverse = True)
     
    # Stores count of subsets possible
    maxSub = 0;
 
    # Stores count of elements
    # in current subset
    size = 0;
 
    # Traverse the array arr[]
    for i in range(N) :
 
        # Update size
        size += 1;
 
        # If product of the smallest element
        # present in the current subset and
        # size of current subset is >= K
        if (arr[i] * size >= X) :
 
            # Update maxSub
            maxSub += 1;
 
            # Update size
            size = 0;
    print(maxSub);
 
# Driver Code
if __name__ == "__main__" :
 
    # Given array
    arr = [ 1, 3, 3, 7 ];
 
    # Size of the array
    N = len(arr);
 
    # Given value of X
    X = 3;
 
    maxDivisions(arr, N, X);
     
    # This code is contributed by AnkThon
C#



// C# program for the above approach
using System;
class GFG
{
 
  // Function to count maximum subsets into
  // which the given array can be split such
  // that it satisfies the given condition
  static void maxDivisions(int[] arr, int N, int X)
  {
 
    // Sort the array in decreasing order
    Array.Sort(arr);
    Array.Reverse(arr);
 
    // Stores count of subsets possible
    int maxSub = 0;
 
    // Stores count of elements
    // in current subset
    int size = 0;
 
    // Traverse the array arr[]
    for (int i = 0; i < N; i++)
    {
 
      // Update size
      size++;
 
      // If product of the smallest element
      // present in the current subset and
      // size of current subset is >= K
      if (arr[i] * size >= X)
      {
 
        // Update maxSub
        maxSub++;
 
        // Update size
        size = 0;
      }
    }
 
    Console.WriteLine(maxSub);
  }
 
  // Driver Code
  public static void Main()
  {
 
    // Given array
    int[] arr = { 1, 3, 3, 7 };
 
    // Size of the array
    int N = arr.Length;
 
    // Given value of X
    int X = 3;
    maxDivisions(arr, N, X);
  }
}
 
// This code is contributed by subhammahato348.
Javascript



<script>
// javascript program of the above approach
 
// Function to count maximum subsets into
// which the given array can be split such
// that it satisfies the given condition
function maxDivisions(arr, N, X)
{
 
    // Sort the array in decreasing order
    arr.sort();
 
    // Stores count of subsets possible
    let maxSub = 0;
 
    // Stores count of elements
    // in current subset
    let size = 0;
 
    // Traverse the array arr[]
    for (let i = 0; i < N; i++)
    {
 
        // Update size
        size++;
 
        // If product of the smallest element
        // present in the current subset and
        // size of current subset is >= K
        if (arr[i] * size >= X)
        {
 
            // Update maxSub
            maxSub++;
 
            // Update size
            size = 0;
        }
    }
    document.write(maxSub + "<br/>");
}
 
    // Driver Code
     
    // Given array
    let arr = [ 1, 3, 3, 7 ];
 
    // Size of the array
    let N = arr.length;
 
    // Given value of X
    let X = 3;
    maxDivisions(arr, N, X);
 
</script>
Output: 
3
 
Time Complexity: O(N * log(N))
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
Minimize insertions required to make all characters of a given string equal
Next

Find the duplicate characters in a string in O(1) space
Recommended Articles
Page :
Maximum number of subsets an array can be split into such that product of their minimums with size of subsets is at least K
21, Apr 21
Split array into minimum number of subsets such that elements of all pairs are present in different subsets at least once
04, Jan 21
Minimum length of a rod that can be split into N equal parts that can further be split into given number of equal parts
16, May 21
Find the lexicographically smallest string which satisfies the given condition
10, Apr 19
Minimum changes required such that the string satisfies the given condition
12, Mar 19
Split array into K subsets to maximize sum of their second largest elements
01, Dec 20
Split array into K subsets to maximize their sum of maximums and minimums
08, Jul 20
Smallest index in the given array that satisfies the given condition
15, Mar 19
Maximum size of sub-array that satisfies the given condition
31, Jan 19
Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
11, Jul 19
Check if an array can be split into subsets of K consecutive elements
15, Jul 20
Subarray permutation that satisfies the given condition
08, Jan 20
Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
03, Jan 21
Split array into K non-empty subsets such that sum of their maximums and minimums is maximized
19, Apr 21
Split array into two equal length subsets such that all repetitions of a number lies in a single subset
28, Sep 20
Split N powers of 2 into two subsets such that their difference of sum is minimum
07, May 20
Count ways to split array into K non-intersecting subsets
19, Oct 20
Count ways to split array into pair of subsets with difference between their sum equal to K
10, Feb 21
Count ways to split array into two subsets having difference between their sum equal to K
09, Jun 21
Generate an array B[] from the given array A[] which satisfies the given conditions
21, Oct 19
Split an Array A[] into Subsets having equal Sum and sizes equal to elements of Array B[]
21, Aug 20
Count ways to split a string into two subsets that are reverse of each other
29, Jun 21
Check if it is possible to split given Array into K odd-sum subsets
19, Jun 20
Count of operations required to update the array such that it satisfies the given conditions
26, Sep 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ananyadixit8
@ananyadixit8
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

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

Lightbox

Start Your Coding Journey Now!