# Maximum amount of capital required for selecting at most K projects

• Difficulty Level : Hard
• Last Updated : 11 Jun, 2021

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 ith 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 0th project can be chosen at a cost of C i.e., 0, and after finishing the capital added to W i.e., W becomes W + P = 1.
Project 2: With the given amount of W as 1, the 2nd project can be chosen at a cost of C i.e., 1, and after finishing the capital added to W i.e., W becomes W + P = 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:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``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 > 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 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)

My Personal Notes arrow_drop_up