Maximum number of diamonds that can be gained in K minutes

Given an array arr[] consisting of N positive integers such that arr[i] represents that the i^th bag contains arr[i] diamonds and a positive integer K, the task is to find the maximum number of diamonds that can be gained in exactly K minutes if dropping a bag takes 1 minute such that if a bag with P diamonds is dropped, then it changes to [P/2] diamonds, and P diamonds are gained.

Examples:

Input: arr[] = {2, 1, 7, 4, 2}, K = 3
Output: 14
Explanation:
The initial state of bags is {2, 1, 7, 4, 2}.
Operation 1: Take all diamonds from third bag i.e., arr[2](= 7), the state of bags becomes: {2, 1, 3, 4, 2}.
Operation 2: Take all diamonds from fourth bag i.e., arr[3](= 4), the state of bags becomes: {2, 1, 3, 2, 2}.
Operation 3: Take all diamonds from Third bag i.e., arr[2](= 3), the state of bags becomes{2, 1, 1, 2, 2}.
Therefore, the total diamonds gains is 7 + 4 + 3 = 14.

Input: arr[] = {7, 1, 2}, K = 2
Output: 10

Approach: The given problem can be solved by using the Greedy Approach with the help of max-heap. Follow the steps below to solve the problem:

• Initialize a priority queue, say PQ, and insert all the elements of the given array into PQ.
• Initialize a variable, say ans as 0 to store the resultant maximum diamond gained.
• Iterate a loop until the priority queue PQ is not empty and the value of K > 0:
  • Pop the top element of the priority queue and add the popped element to the variable ans.
  • Divide the popped element by 2 and insert it into the priority queue PQ.
  • Decrement the value of K by 1.
• After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum number
// of diamonds that can be gained in
// exactly K minutes
void maxDiamonds(int A[], int N, int K)
{
    // Stores all the array elements
    priority_queue<int> pq;

    // Push all the elements to the
    // priority queue
    for (int i = 0; i < N; i++) {
        pq.push(A[i]);
    }

    // Stores the required result
    int ans = 0;

    // Loop while the queue is not
    // empty and K is positive
    while (!pq.empty() && K--) {

        // Store the top element
        // from the pq
        int top = pq.top();

        // Pop it from the pq
        pq.pop();

        // Add it to the answer
        ans += top;

        // Divide it by 2 and push it
        // back to the pq
        top = top / 2;
        pq.push(top);
    }

    // Print the answer
    cout << ans;
}

// Driver Code
int main()
{
    int A[] = { 2, 1, 7, 4, 2 };
    int K = 3;
    int N = sizeof(A) / sizeof(A[0]);
    maxDiamonds(A, N, K);

    return 0;
}

Java

// Java program for the above approach
import java.util.*;

class GFG{

// Function to find the maximum number
// of diamonds that can be gained in
// exactly K minutes
static void maxDiamonds(int A[], int N, int K)
{

    // Stores all the array elements
    PriorityQueue<Integer> pq = new PriorityQueue<>(
        (a, b) -> b - a);

    // Push all the elements to the
    // priority queue
    for(int i = 0; i < N; i++)
    {
        pq.add(A[i]);
    }

    // Stores the required result
    int ans = 0;

    // Loop while the queue is not
    // empty and K is positive
    while (!pq.isEmpty() && K-- > 0)
    {

        // Store the top element
        // from the pq
        int top = pq.peek();

        // Pop it from the pq
        pq.remove();

        // Add it to the answer
        ans += top;

        // Divide it by 2 and push it
        // back to the pq
        top = top / 2;
        pq.add(top);
    }

    // Print the answer
    System.out.print(ans);
}

// Driver Code
public static void main(String[] args)
{
    int A[] = { 2, 1, 7, 4, 2 };
    int K = 3;
    int N = A.length;

    maxDiamonds(A, N, K);
}
}

// This code is contributed by 29AjayKumar

Python3

# Python3 program for the above approach

# Function to find the maximum number
# of diamonds that can be gained in
# exactly K minutes
def maxDiamonds(A, N, K):

    # Stores all the array elements
    pq = []

    # Push all the elements to the
    # priority queue
    for i in range(N):
        pq.append(A[i])

    pq.sort()

    # Stores the required result
    ans = 0

    # Loop while the queue is not
    # empty and K is positive
    while (len(pq) > 0 and K > 0):
        pq.sort()

        # Store the top element
        # from the pq
        top = pq[len(pq) - 1]

        # Pop it from the pq
        pq = pq[0:len(pq) - 1]

        # Add it to the answer
        ans += top

        # Divide it by 2 and push it
        # back to the pq
        top = top // 2;
        pq.append(top)
        K -= 1

    # Print the answer
    print(ans)

# Driver Code
if __name__ == '__main__':

    A = [ 2, 1, 7, 4, 2 ]
    K = 3
    N = len(A)

    maxDiamonds(A, N, K)

# This code is contributed by SURENDRA_GANGWAR

C#

// C# program for the above approach
using System;
using System.Collections;
using System.Collections.Generic;

class GFG{

// Function to find the maximum number
// of diamonds that can be gained in
// exactly K minutes
static void maxDiamonds(int []A, int N, int K)
{

    // Stores all the array elements
    var pq = new List<int>();

    // Push all the elements to the
    // priority queue
    for(int i = 0; i < N; i++)
    {
        pq.Add(A[i]);
    }

    // Stores the required result
    int ans = 0;

    // Loop while the queue is not
    // empty and K is positive
    while (pq.Count!=0 && K-- > 0)
    {
        pq.Sort();
        // Store the top element
        // from the pq
        int top = pq[pq.Count-1];

        // Pop it from the pq
        pq.RemoveAt(pq.Count-1);

        // Add it to the answer
        ans += top;

        // Divide it by 2 and push it
        // back to the pq
        top = top / 2;
        pq.Add(top);
    }

    // Print the answer
    Console.WriteLine(ans);
}

// Driver Code
public static void Main(string[] args)
{
    int []A= { 2, 1, 7, 4, 2 };
    int K = 3;
    int N = A.Length;

    maxDiamonds(A, N, K);
}
}

// This code is contributed by rrrtnx.

Javascript

<script>

// JavaScript program for the above approach


// Function to find the maximum number
// of diamonds that can be gained in
// exactly K minutes
function maxDiamonds(A, N, K) {
    // Stores all the array elements
    let pq = [];

    // Push all the elements to the
    // priority queue
    for (let i = 0; i < N; i++) {
        pq.push(A[i]);
    }

    // Stores the required result
    let ans = 0;

    // Loop while the queue is not
    // empty and K is positive
    pq.sort((a, b) => a - b)

    while (pq.length && K--) {

        pq.sort((a, b) => a - b)
        // Store the top element
        // from the pq
        let top = pq[pq.length - 1];

        // Pop it from the pq
        pq.pop();

        // Add it to the answer
        ans += top;

        // Divide it by 2 and push it
        // back to the pq
        top = Math.floor(top / 2);
        pq.push(top);
    }

    // Print the answer
    document.write(ans);
}

// Driver Code

let A = [2, 1, 7, 4, 2];
let K = 3;
let N = A.length;
maxDiamonds(A, N, K);

</script>

Output:

14

Time Complexity: O((N + K)*log N)
Auxiliary Space: O(N)