Maximize the Profit as the Salesman - Practice Coding Problems

Maximize the Profit as the Salesman - Problem

You're a real estate salesman working on a street with n houses numbered from 0 to n-1. Multiple buyers have made offers to purchase contiguous blocks of houses, and each buyer is willing to pay a specific amount of gold for their desired range.

Given a 2D array offers where offers[i] = [start_i, end_i, gold_i], the i-th buyer wants to purchase all houses from start_i to end_i (inclusive) for gold_i amount of gold.

Your goal: Strategically select offers to maximize your total earnings. Remember that no house can be sold to multiple buyers, and some houses may remain unsold.

This is essentially a weighted interval scheduling problem where you need to find the optimal combination of non-overlapping offers that gives you maximum profit.

Input & Output

example_1.py — Basic case

$ Input: n = 5, offers = [[0,0,1],[0,2,2],[1,3,2]]

› Output: 3

💡 Note: We can select offers [0,0,1] and [1,3,2] without overlap, giving us profit 1+2=3. The offer [0,2,2] overlaps with [1,3,2], so we can't take both.

example_2.py — No overlaps

$ Input: n = 5, offers = [[0,1,3],[2,3,4],[4,4,2]]

› Output: 9

💡 Note: All three offers are non-overlapping, so we can take all of them: 3+4+2=9.

example_3.py — Choose wisely

$ Input: n = 3, offers = [[0,2,10],[1,1,5]]

› Output: 10

💡 Note: We can either take [0,2,10] for profit 10, or [1,1,5] for profit 5. Since they overlap, we choose the more profitable one.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ offers.length ≤ 10⁵
offers[i].length == 3
0 ≤ start_i ≤ end_i ≤ n-1
1 ≤ gold_i ≤ 10³
No house can be sold to multiple buyers

Visualization

Tap to expand

Understanding the Visualization

Organize Offers

Sort all buyer offers by their end house number - this helps us process them in a logical order

Make Strategic Decisions

For each offer, decide: should I take this deal or skip it? Consider both the immediate profit and future opportunities

Find Compatible Deals

Use binary search to quickly find the latest deal that doesn't conflict with the current one

Build Optimal Portfolio

Combine the best deals to create your maximum profit portfolio

Key Takeaway

🎯 Key Insight: By sorting offers by end time and using dynamic programming with binary search, we can efficiently find the optimal combination of non-overlapping deals in O(n log n) time, much better than the exponential brute force approach.

Asked in

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

This is a classic weighted interval scheduling problem. The optimal approach uses dynamic programming with binary search after sorting offers by end time. For each offer, we decide whether to take it (plus the best solution from non-overlapping previous offers) or skip it. Binary search helps us efficiently find the latest non-overlapping offer, achieving O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n × n²)	O(n)	Generate all possible subsets of offers and find the maximum profit among valid combinations
Dynamic Programming + Binary Search (Optimal)	O(n log n)	O(n)	Sort offers by end time, then use DP with binary search to find optimal non-overlapping selections

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsets of offers using bit manipulation
For each subset, check if any two offers overlap
If no overlaps exist, calculate total profit for this subset
Keep track of maximum profit seen so far
Return the maximum profit

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subsets

Use bit manipulation to generate all 2^n possible combinations

Check Overlaps

For each subset, verify no two intervals overlap

Calculate Profit

Sum up gold amounts for valid combinations

Track Maximum

Keep the highest profit found so far

Code -

solution.c — C

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

int maximizeTheProfit(int n, int offers[][3], int numOffers) {
    int maxProfit = 0;
    
    for (int mask = 0; mask < (1 << numOffers); mask++) {
        int currentProfit = 0;
        int validOffers[20][3];
        int count = 0;
        
        for (int i = 0; i < numOffers; i++) {
            if (mask & (1 << i)) {
                validOffers[count][0] = offers[i][0];
                validOffers[count][1] = offers[i][1];
                validOffers[count][2] = offers[i][2];
                currentProfit += offers[i][2];
                count++;
            }
        }
        
        int valid = 1;
        for (int i = 0; i < count && valid; i++) {
            for (int j = i + 1; j < count; j++) {
                if (!(validOffers[i][1] < validOffers[j][0] ||
                      validOffers[j][1] < validOffers[i][0])) {
                    valid = 0;
                    break;
                }
            }
        }
        
        if (valid && currentProfit > maxProfit) {
            maxProfit = currentProfit;
        }
    }
    
    return maxProfit;
}

int main() {
    printf("Solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n²)

2^n subsets to check, each requiring O(n²) time to verify no overlaps

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current subset and tracking maximum profit

⚡ Linearithmic Space

48.2K Views

High Frequency

~18 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler