# Solution: Maximize Capital

Let's solve the Maximize Capital problem using the Two Heaps pattern.

## Statement

A busy investor with an initial capital, `c`

, needs an automated investment program. They can select `k`

distinct projects from a list of `n`

projects with corresponding `capitals`

requirements and expected `profits`

. For a given project $i$, its capital requirement is $capitals[i]$ , and the profit it yields is $profits[i]$.

The goal is to maximize their cumulative capital by selecting a maximum of `k`

distinct projects to invest in, subject to the constraint that the investorâ€™s current capital must be greater than or equal to the capital requirement of all selected projects.

When a selected project from the identified ones is finished, the pure profit from the project, along with the starting capital of that project is returned to the investor. This amount will be added to the total capital held by the investor. Now, the investor can invest in more projects with the new total capital. It is important to note that each project can only be invested once.

As a basic risk-mitigation measure, the investor wants to limit the number of projects they invest in. For example, if `k`

is $2$, the program should identify the two projects that maximize the investorâ€™s profits while ensuring that the investorâ€™s capital is sufficient to invest in the projects.

Overall, the program should help the investor to make informed investment decisions by picking a list of a maximum of `k`

distinct projects to maximize the final profit while mitigating the risk.

**Constraints:**

- $1 \leq$
`k`

$\leq 10^3$ - $0 \leq$
`c`

$\leq 10^9$ - $1 \leq$
`n`

$\leq 10^3$ `k`

$\leq$`n`

`n`

$==$`profits.length`

`n`

$==$`capitals.length`

- $0 \leq$
`profits[i]`

$\leq 10^4$ - $0 \leq$
`capitals[i]`

$\leq 10^9$

## Solution

You may have already brainstormed some approaches and have an idea of how to solve this problem. Letâ€™s explore some of these approaches and figure out which one to follow based on considerations such as time complexity and implementation constraints.

### Naive approach

The naive approach is to traverse every value of the `capitals`

array based on the available capital. If the current capital is less than or equal to the capital value in the array, then store the profit value in a new array that corresponds to the capital index. Whenever the current capital becomes less than the capital value in the array, weâ€™ll select the project with the largest profit value. The selected profit value will be added to the previous capital. Repeat this process until we get the required number of projects containing the maximum profit.

We got the solution we needed, but at what cost? The time complexity is $O(n^2)$, where n represents the number of projects. This is because we need $O(n)$ time to traverse the `capitals`

array in order to find affordable projects. Additonally, for each subset of affordable projects, we would need another $O(n)$ search to narrow down the project list to the one that yields the highest profit. The space complexity for storing the profit values in a new array is $O(n)$.

### Optimized approach using two heaps

This problem can be solved efficiently by using two heaps. We can minimize the time required to find affordable projects by maintaining the required `capitals`

of the projects in a min-heap. Similarly, to quickly find the project with the highest profit, we can maintain `profits`

of the projects in a max-heap.

The slide deck below illustrates the key steps of the solution, with `k`

$= 2$ and `c`

$= 1$:

Level up your interview prep. Join Educative to access 80+ hands-on prep courses.