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:4Explanation: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**.

- Push profit of all the projects that have not been selected yet and whose capital is
- 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)

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****.**