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$

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.

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)$.

This approach optimizes the selection of projects to maximize capital using a two-heap method. By pushing projects’ capital into a min-heap, projects are organized in ascending order of capital needed. Then, we choose projects from the min-heap that fit within our available capital, prioritizing those with the lowest costs. The selected projects are evaluated for their profitability by inserting their profits into a max-heap. This allows for prioritizing projects based on their potential return on investment. The most profitable project from the max-heap is chosen, and its profit is added to the current capital. The selected project is excluded from the list of available projects, and the same steps are repeated with the updated capital to select the next project. This process—selecting projects based on the capital requirement, evaluating project affordability, selecting for maximum profit, and updating available capital—is repeated for $k$ times to select $k$ projects that yield maximum profit.

The slide deck below illustrates the key steps of the solution, with k $= 2$ and c $= 1$: