Skip to content
Related Articles

Related Articles

Maximize count of subsets into which the given array can be split such that it satisfies the given condition
  • Last Updated : 15 Feb, 2021

Given an array arr[] of size N and a positive integer X, the task is to the partition the array into maximum number of subsets such that 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 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 right most 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 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.
Output: 
3
 
Time Complexity: O(N * log(N))
Auxiliary Space: O(1)
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
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 :
Split array into minimum number of subsets such that elements of all pairs are present in different subsets at least once
04, Jan 21
Find the lexicographically smallest string which satisfies the given condition
10, Apr 19
Split array into K subsets to maximize their sum of maximums and minimums
08, Jul 20
Split array into K subsets to maximize sum of their second largest elements
01, Dec 20
Minimum changes required such that the string satisfies the given condition
12, Mar 19
Partition an array of non-negative integers into two subsets such that average of both the subsets is equal
11, Jul 19
Smallest index in the given array that satisfies the given condition
15, Mar 19
Check if an array can be split into subsets of K consecutive elements
15, Jul 20
Maximum size of sub-array that satisfies the given condition
31, Jan 19
Split array into two equal length subsets such that all repetitions of a number lies in a single subset
28, Sep 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
Subarray permutation that satisfies the given condition
08, Jan 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
Split an Array A[] into Subsets having equal Sum and sizes equal to elements of Array B[]
21, Aug 20
Check if it is possible to split given Array into K odd-sum subsets
19, Jun 20
Generate an array B[] from the given array A[] which satisfies the given conditions
21, Oct 19
Split Array into min number of subsets with difference between each pair greater than 1
25, Jul 20
Split array into minimum number of subsets having maximum pair sum at most K
09, Oct 20
Split array into equal length subsets with maximum sum of Kth largest element of each subset
02, Dec 20
Split array into K-length subsets to minimize sum of second smallest element of each subset
25, Dec 20
Split array into minimum number of subsets with every element of a subset divisible by its minimum
12, Feb 21
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