Related Articles

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

• 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)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :