通过销售 M 种产品来最大化利润，使得产品的利润是该供应商剩余的产品数量

给定一个由N 个正整数组成的数组arr[] ，其中arr[i]表示第i^个供应商拥有的产品数量和一个正整数M ，任务是通过销售M产品找到最大利润，如果利润特定产品的数量与该供应商剩余的产品数量相同。

例子：

Input: arr[] = {4, 6}, M = 4
Output: 19
Explanation:
Below are the order of the product sell to gain the maximum profit:
Product 1: Sell a product from the second supplier, then the array modifies to {4, 5} and the profit is 6.
Product 2: Sell a product from the second supplier, then the array modifies to{4, 4} and the profit is 6 + 5 = 11.
Product 3: Sell a product from the second supplier, then the array modifies to {4, 3} and the profit is 6 + 5 + 4 = 15.
Product 4: Sell a product from the first supplier, then the array modifies to {3, 3} and the profit is 6 + 5 + 4 + 4 = 19.
Therefore, the maximum profit that can be obtained by selling 4 products is 19.

Input: arr[] = {1, 2, 3}, M = 2
Output: 5

朴素的方法：可以通过从当前剩余产品数量最多的供应商处销售产品来解决给定的问题。所以，思路是迭代一个循环M次，在每次迭代中找到数组中最大元素的值，并将其值添加到利润中，然后将其在数组中的值减1。 循环后，打印利润的价值。

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

高效的方法：上述方法也可以通过使用最大堆来优化，以在O(log N)时间内跟踪数组中的最大元素。请按照以下步骤解决问题：

• 使用优先级队列初始化最大堆，比如Q以跟踪数组中存在的最大元素。
• 遍历数组arr[]并插入堆Q 中的所有元素。
• 初始化一个变量，比如maxProfit为0来存储获得的结果最大利润。
• 迭代一个循环直到M > 0 ，并执行以下步骤：
  • 将M的值减少1 。
  • 将优先级队列Q的顶部元素的值存储在变量X 中，并将其从优先级队列中弹出。
  • 将X的值添加到变量maxProfit并将(X – 1)插入变量Q 。
• 完成上述步骤后，打印maxProfit的值作为结果。

下面是上述方法的实现：

Java

// Java program for the above approach
  
import java.util.*;
  
class GFG {
  
    // Function to find the maximum profit
    // by selling M number of products
    static void findMaximumProfit(
        int[] arr, int M, int N)
    {
  
        // Initialize a Max-Heap to keep
        // track of the maximum value
        PriorityQueue max_heap
            = new PriorityQueue<>((a, b) -> b - a);
  
        // Stores the maximum profit
        int maxProfit = 0;
  
        // Traverse the array and push
        // all the elements in max_heap
        for (int i = 0; i < N; i++)
            max_heap.add(arr[i]);
  
        // Iterate a loop until M > 0
        while (M > 0) {
  
            // Decrement the value
            // of M by 1
            M--;
  
            // Pop the maximum element
            // from the heap
            int X = max_heap.poll();
  
            // Update the maxProfit
            maxProfit += X;
  
            // Push (X - 1) to max heap
            max_heap.add(X - 1);
        }
  
        // Print the result
        System.out.println(maxProfit);
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 4, 6 };
        int M = 4;
        int N = arr.length;
        findMaximumProfit(arr, M, N);
    }
}

输出：

19

时间复杂度： O(M * log(N))
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live