LeetCode - IPO

Suppose LeetCode will start its IPO soon. In order to sell a good price of its shares to Venture Capital, LeetCode would like to work on some projects to increase its capital before the IPO. Since it has limited resources, it can only finish at most k distinct projects before the IPO. Help LeetCode design the best way to maximize its total capital after finishing at most k distinct projects.

You are given n projects where the ith project has a pure profit profits[i] and a minimum capital of capital[i] is needed to start it.

Initially, you have w capital. When you finish a project, you will obtain its pure profit and the profit will be added to your total capital.

Pick a list of at most k distinct projects from given projects to maximize your final capital, and return the final maximized capital.

The answer is guaranteed to fit in a 32-bit signed integer.

 

Example 1:

Input: k = 2, w = 0, profits = [1,2,3], capital = [0,1,1]
Output: 4
Explanation: Since your initial capital is 0, you can only start the project indexed 0.
After finishing it you will obtain profit 1 and your capital becomes 1.
With capital 1, you can either start the project indexed 1 or the project indexed 2.
Since you can choose at most 2 projects, you need to finish the project indexed 2 to get the maximum capital.
Therefore, output the final maximized capital, which is 0 + 1 + 3 = 4.

Example 2:

Input: k = 3, w = 0, profits = [1,2,3], capital = [0,1,2]
Output: 6

 

Constraints:

• 1 <= k <= 105
• 0 <= w <= 109
• n == profits.length
• n == capital.length
• 1 <= n <= 105
• 0 <= profits[i] <= 104
• 0 <= capital[i] <= 109

 

ChatGPT's Solution:

class Solution:
    def findMaximizedCapital(self, k: int, w: int, profits: List[int], capital: List[int]) -> int:
        # Step 1: Create a list of projects with their capital and profit
        projects = list(zip(capital, profits))

        # Step 2: Sort the projects by their capital requirement
        projects.sort()  # Sort by the minimum capital required for each project

        # Step 3: Create a max-heap to store the profits of projects that can be started
        max_heap = []
        index = 0

        # Step 4: Do the loop for at most k projects
        for _ in range(k):
            # Add all projects that we can affor (capital <= w)
            while index < len(projects) and projects[index][0] <= w:
                heapq.heappush(max_heap, -projects[index][1])  # Use negative to simulate max-heap
                index += 1
            
            # If we can choose a project, pick the one with the maximum profit
            if max_heap:
                w += -heapq.heappop(max_heap)  # Add the max profit to the capital
        
        return w

 

 

Explanation:

1. Input Data: k, w, profits, and capital are given as inputs.

   • k is the maximum number of projects we can complete.

   • w is the initial capital.

   • profits is a list where profits[i] is the profit from project i.

   • capital is a list where capital[i] is the minimum capital required for project i.

2. Project Sorting: We sort the projects by their capital requirement. This way, we can easily find the projects that we can afford given our current capital.

3. Heap for Maximum Profit: We use a max-heap (by pushing negative values) to always choose the project with the highest profit once we can afford multiple projects.

4. Looping: We repeat the process for k iterations (or until we can't afford any more projects).

5. Output: The final capital after completing the best projects is returned.

This approach ensures that we are selecting the most profitable projects we can afford at each step.