IPO - Practice Coding Problems

IPO - Problem

IPO Capital Maximization Problem

Imagine you're the CEO of LeetCode preparing for your company's Initial Public Offering (IPO)! To attract venture capital and maximize your share price, you need to strategically complete projects to grow your capital before going public.

You have n available projects, each with:
• A minimum capital requirement capital[i] to start the project
• A guaranteed pure profit profits[i] upon completion

Starting with w initial capital, you can complete at most k projects before your IPO deadline. Each completed project adds its profit to your total capital, potentially unlocking more expensive (and profitable) projects.

Goal: Select up to k projects to maximize your final capital before the IPO.

Example: With initial capital of $0 and projects requiring [$1, $2, $3] with profits of [$1, $2, $3], you might start with the cheapest project to build capital for more profitable ones!

Input & Output

example_1.py — Basic IPO Strategy

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

› Output: 4

💡 Note: Start with $0 capital. Project 0 requires $0 and gives $1 profit → Capital becomes $1. Now we can afford projects 1 and 2 (both need $1). Project 2 gives higher profit ($3), so select it → Final capital: $1 + $3 = $4

example_2.py — Capital Constraint

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

› Output: 6

💡 Note: Start with $0. Only project 0 is affordable → Capital becomes $1. Now project 1 is affordable → Capital becomes $3. Finally project 2 is affordable → Final capital: $6

example_3.py — Project Limit

$ Input: k = 1, w = 2, profits = [1,2,3], capital = [1,1,2]

› Output: 5

💡 Note: With $2 starting capital, we can afford projects 0, 1, and 2. Limited to k=1 project, we choose the most profitable (project 2 with profit $3) → Final capital: $2 + $3 = $5

Constraints

1 ≤ k ≤ 10⁵
0 ≤ w ≤ 10⁹
n == profits.length
n == capital.length
1 ≤ n ≤ 10⁵
0 ≤ profits[i] ≤ 10⁴
0 ≤ capital[i] ≤ 10⁹
Answer is guaranteed to fit in a 32-bit signed integer

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Sort all projects by capital requirement in a min-heap. Start with given capital w.

Find Affordable Projects

Move all projects we can currently afford from the capital-heap to the profit-heap.

Greedy Selection

Always pick the most profitable project from available options.

Capital Growth

Add the project's profit to our capital, potentially unlocking more expensive projects.

Repeat Process

Continue for k iterations or until no more affordable projects exist.

Key Takeaway

🎯 Key Insight: The greedy choice (always pick the most profitable affordable project) is optimal because it maximizes capital growth at each step, unlocking the most future opportunities. This problem has optimal substructure - the best choice now leads to the best overall result.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a two-heap greedy strategy: maintain a min-heap of projects sorted by capital requirement and a max-heap of affordable projects sorted by profit. For each of k iterations, move all newly affordable projects to the profit heap, then greedily select the most profitable one. This approach achieves O(n log n + k log n) time complexity and guarantees the maximum possible capital.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Combinations)	O(2^n * k * n)	O(k)	Try all possible combinations of k projects that can be afforded
Greedy with Two Heaps (Optimal)	O(n log n + k log n)	O(n)	Use min-heap for affordable projects and max-heap for profits to greedily select optimal projects

Brute Force (All Combinations) — Algorithm Steps

Generate all combinations of projects of size up to k
For each combination, simulate executing projects in optimal order
Check if we have enough capital for each project at execution time
Track the maximum final capital across all valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to select up to k projects from n available projects

Simulate Each Combo

For each combination, try to execute projects in optimal order (most profitable among affordable)

Track Maximum

Keep track of the combination that yields the highest final capital

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int capital;
    int profit;
    int idx;
} Project;

int compare_projects(const void* a, const void* b) {
    Project* pa = (Project*)a;
    Project* pb = (Project*)b;
    return pa->capital - pb->capital;
}

void generateCombinations(int** result, int* resultSize, int* current, int currentSize, int start, int n, int r) {
    if (currentSize == r) {
        result[*resultSize] = malloc(r * sizeof(int));
        memcpy(result[*resultSize], current, r * sizeof(int));
        (*resultSize)++;
        return;
    }
    
    for (int i = start; i < n; i++) {
        current[currentSize] = i;
        generateCombinations(result, resultSize, current, currentSize + 1, i + 1, n, r);
    }
}

int findMaximizedCapital(int k, int w, int* profits, int profitsSize, int* capital, int capitalSize) {
    int n = profitsSize;
    int maxCapital = w;
    
    for (int r = 0; r <= (k < n ? k : n); r++) {
        int** combinations = malloc(10000 * sizeof(int*));
        int combinationCount = 0;
        int* current = malloc(r * sizeof(int));
        
        generateCombinations(combinations, &combinationCount, current, 0, 0, n, r);
        
        for (int c = 0; c < combinationCount; c++) {
            int availableCapital = w;
            Project* projects = malloc(r * sizeof(Project));
            
            for (int i = 0; i < r; i++) {
                int idx = combinations[c][i];
                projects[i].capital = capital[idx];
                projects[i].profit = profits[idx];
                projects[i].idx = idx;
            }
            
            qsort(projects, r, sizeof(Project), compare_projects);
            
            int executed = 0;
            int* used = calloc(n, sizeof(int));
            
            while (executed < r) {
                int bestProfit = -1;
                int bestIdx = -1;
                
                for (int i = 0; i < r; i++) {
                    if (!used[projects[i].idx] && projects[i].capital <= availableCapital && projects[i].profit > bestProfit) {
                        bestProfit = projects[i].profit;
                        bestIdx = projects[i].idx;
                    }
                }
                
                if (bestIdx == -1) break;
                
                availableCapital += bestProfit;
                used[bestIdx] = 1;
                executed++;
            }
            
            if (executed == r && availableCapital > maxCapital) {
                maxCapital = availableCapital;
            }
            
            free(projects);
            free(used);
        }
        
        for (int i = 0; i < combinationCount; i++) {
            free(combinations[i]);
        }
        free(combinations);
        free(current);
    }
    
    return maxCapital;
}

int main() {
    int profits[] = {1, 2, 3};
    int capital[] = {0, 1, 1};
    printf("%d\n", findMaximizedCapital(2, 0, profits, 3, capital, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * k * n)

2^n combinations, each requiring k*n operations to simulate and validate

⚠ Quadratic Growth

Space Complexity

O(k)

Only need to store current combination being evaluated

✓ Linear Space

62.0K Views

High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler