最大化具有最小元素乘积且子集大小至少为X的子集数

给定由N个整数和整数X组成的数组arr [] ，任务是计算给定数组具有的最大子集数

Smallest element of the Subset * Size of the Subset ≥ X

例子：

Input: arr[] = {7, 11, 2, 9, 5}, X = 10
Output: 2
Explanation: 
One of the possible solution is {7, 9} and {11, 5}. 
In subset {7, 9} the smallest element (= 7), size of subset (= 2). 
Therefore, the product of the smallest element of the subset and the size of the subset is equal to 14 ( > 10). 
In subset {11, 5} the smallest element (= 5), size of subset (= 2). 
Therefore, the product of the smallest element of the subset * size of the subset is equal to 10 
Hence, the required output is 2

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

方法：可以使用贪婪方法解决问题。想法是按降序对数组进行排序，然后逐个遍历元素以检查所需条件。
请按照以下步骤解决问题。

1. 按降序对数组进行排序。
2. 初始化变量counter ， sz来存储可能的子集的数量以及当前子集的大小。
3. 遍历给定数组，并检查arr [i] * sz≥X 。如果确定为真，则将sz和增量计数器重置为1。
4. 最后，在遍历数组后，将计数器打印为所需答案。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
  
#include 
using namespace std;
  
// Comperator function to return
// the greater of two numbers
bool comp(int a, int b)
{
    return a > b;
}
  
// Function to return the maximum count
// of subsets possible which
// satisy the above condition
int maxSubset(int arr[], int N, int X)
{
  
    // Sort the array in
    // descending order
    sort(arr, arr + N, comp);
  
    // Stores the count of subsets
    int counter = 0;
  
    // Stores the size of
    // the current subset
    int sz = 0;
  
    for (int i = 0; i < N; i++) 
    {
        sz++;
  
        // Check for the necessary
        // conditions
        if (arr[i] * sz >= X) {
            counter++;
            sz = 0;
        }
    }
    return counter;
}
  
// Driver Code
int main()
{
    int arr[] = { 7, 11, 2, 9, 5 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int X = 10;
    cout << maxSubset(arr, N, X);
}

Java

// Java program to implement
// the above approach
import java.util.*;
  
class GFG{
  
// Function to return the maximum count
// of subsets possible which
// satisy the above condition
static int maxSubset(Integer arr[], int N, 
                                    int X)
{
      
    // Sort the array in
    // descending order
    Arrays.sort(arr, Collections.reverseOrder());
  
    // Stores the count of subsets
    int counter = 0;
  
    // Stores the size of
    // the current subset
    int sz = 0;
  
    for(int i = 0; i < N; i++) 
    {
        sz++;
  
        // Check for the necessary
        // conditions
        if (arr[i] * sz >= X)
        {
            counter++;
            sz = 0;
        }
    }
    return counter;
}
  
// Driver Code
public static void main(String[] args)
{
    Integer arr[] = { 7, 11, 2, 9, 5 };
    int N = arr.length;
    int X = 10;
      
    System.out.print(maxSubset(arr, N, X));
}
}
  
// This code is contributed by 29AjayKumar

Python3

# Python3 Program to implement
# the above approach
  
# Function to return the maximum count
# of subsets possible which
# satisy the above condition
def maxSubset(arr, N, X):
  
    # Sort the array in
    # descending order
    arr.sort(reverse = True)
  
    # Stores the count of subsets
    counter = 0
  
    # Stores the size of
    # the current subset
    sz = 0
  
    for i in range(N):
        sz += 1
  
        # Check for the necessary
        # conditions 
        if(arr[i] * sz >= X):
            counter += 1
            sz = 0
  
    return counter
  
# Driver Code
  
# Given array
arr = [ 7, 11, 2, 9, 5 ]
N = len(arr)
X = 10
  
# Function call
print(maxSubset(arr, N, X))
  
# This code is contributed by Shivam Singh

C#

// C# program to implement
// the above approach
using System;
using System.Linq;
  
class GFG{
  
// Function to return the maximum count
// of subsets possible which
// satisy the above condition
static int maxSubset(int []arr, int N, 
                                int X)
{
      
    // Sort the array in
    // descending order
    Array.Sort(arr);
    Array.Reverse(arr);
  
    // Stores the count of subsets
    int counter = 0;
  
    // Stores the size of
    // the current subset
    int sz = 0;
  
    for(int i = 0; i < N; i++) 
    {
        sz++;
  
        // Check for the necessary
        // conditions
        if (arr[i] * sz >= X)
        {
            counter++;
            sz = 0;
        }
    }
    return counter;
}
  
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 7, 11, 2, 9, 5 };
    int N = arr.Length;
    int X = 10;
      
    Console.Write(maxSubset(arr, N, X));
}
}
  
// This code is contributed by shikhasingrajput

输出：

2

时间复杂度： O(NLog(N))
辅助空间： O(1)