Maximum amount of capital required for selecting at most K projects

Given an integer N, representing number of projects, two arrays P[] and C[], consisting of N integers, and two integers W and K where, W is the initial capital amount, P[i] and C[i] are the profits and capital required to choose the i^th project. The task is to calculate the maximum amount of capital required to choose at most K projects, such that the profit of the chosen projects is added to W and choosing any project required at least C[i].

Examples:

Input: N = 3, W = 0, K = 2, P[] = {1, 2, 3}, C[] = {0, 1, 1}
Output: 4
Explanation:
Project 1: With the given amount of W as 0, the 0^th project can be chosen at a cost of C[0] i.e., 0, and after finishing the capital added to W i.e., W becomes W + P[0] = 1.
Project 2: With the given amount of W as 1, the 2^nd project can be chosen at a cost of C[2] i.e., 1, and after finishing the capital added to W i.e., W becomes W + P[2] = 1 + 3 = 4.

Input: N = 3, W = 1, K = 1, P[] = {10000, 2000, 3000}, C[] = {1, 1, 1}
Output: 10001

Approach: The given problem can be solved using the Greedy Algorithm and priority queue. Follow the steps below to solve the problem:

• Initialize a priority_queue PQ to store all the project’s profit whose capital is at most W.
• Traverse the array C[] using the variable i as the index and push the pair {C[i], i} in a vector of pairs V.
• Sort the vector V in ascending order with respect to the first element.
• Iterate until K is greater than 0:
  • Push profit of all the projects that have not been selected yet and whose capital is at most W in the priority queue PQ.
  • Increment the capital amount W by the maximum element of PQ i.e., W += PQ.top() and then pop the top element of PQ.
  • Decrement the K by 1.
• After completing the above steps, print the value of W as the maximum capital 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 calculate maximum capital
// obtained after choosing at most K
// projects whose capital is less than
// the given cost of projects
int maximizedCapital(int K, int W,
                     vector<int>& profits,
                     vector<int>& capital)
{
    // Stores all projects with
    // capital at most W
    priority_queue<int> pq;

    // Stores the pair of {C[i], i}
    vector<pair<int, int> > v;

    // Traverse the vector C[]
    for (int i = 0;
         i < capital.size(); i++) {
        v.push_back({ capital[i], i });
    }

    // Sort the vector v
    sort(v.begin(), v.end());

    int j = 0;

    while (K) {

        // If capital is at most W
        while (j < (int)capital.size()
               && v[j].first <= W) {

            // Push the profit into
            // priority queue
            pq.push(profits[v[j].second]);

            // Increment j by one
            j++;
        }

        // If pq is not empty
        if (!pq.empty()) {

            // Update the capital W
            W = W + pq.top();

            // Delete the top of pq
            pq.pop();
        }

        // Decrement K by one
        K--;
    }

    // Return the maximum capital
    return W;
}

// Driver Code
int main()
{
    int K = 2;
    int W = 0;
    vector<int> P = { 1, 2, 3 };
    vector<int> C = { 0, 1, 1 };
    cout << maximizedCapital(K, W, P, C);

    return 0;
}

Java

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

public class GFG {

    // Function to calculate maximum capital
    // obtained after choosing at most K
    // projects whose capital is less than
    // the given cost of projects
    static int maximizedCapital(int K, int W, int profits[],
                                int capital[])
    {
        // Stores all projects with
        // capital at most W
        PriorityQueue<Integer> pq = new PriorityQueue<>(
            Collections.reverseOrder());

        // Stores the pair of {C[i], i}
        ArrayList<int[]> v = new ArrayList<>();

        // Traverse the vector C[]
        for (int i = 0; i < capital.length; i++) {
            v.add(new int[] { capital[i], i });
        }

        // Sort the vector v
        Collections.sort(v, (a, b) -> {
            if (a[0] != b[0])
                return a[0] - b[0];
            return a[1] - b[1];
        });

        int j = 0;

        while (K != 0) {

            // If capital is at most W
            while (j < capital.length && v.get(j)[0] <= W) {

                // Add the profit into
                // priority queue
                pq.add(profits[v.get(j)[1]]);

                // Increment j by one
                j++;
            }

            // If pq is not empty
            if (!pq.isEmpty()) {

                // Update the capital W
                W = W + pq.peek();

                // Delete the top of pq
                pq.poll();
            }

            // Decrement K by one
            K--;
        }

        // Return the maximum capital
        return W;
    }

    // Driver Code
    public static void main(String[] args)
    {

        int K = 2;
        int W = 0;
        int P[] = { 1, 2, 3 };
        int C[] = { 0, 1, 1 };

        System.out.println(maximizedCapital(K, W, P, C));
    }
}

// This code is contributed by Kingash.

Output:

4

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