Maximum Profit in Job Scheduling - Practice Coding Problems

Maximum Profit in Job Scheduling - Problem

Job Scheduling for Maximum Profit

Imagine you're a freelance consultant with multiple job offers, but you can't work on overlapping projects. You have n jobs available, where each job i has:

• Start time: startTime[i]
• End time: endTime[i]
• Profit: profit[i]

Your goal is to maximize your total earnings by selecting a subset of non-overlapping jobs. Note that if a job ends at time X, you can immediately start another job that begins at time X.

Example: Jobs [(1,3,$20), (2,5,$30), (4,6,$70)] → Choose jobs 1 and 3 for profit $90

Input & Output

example_1.py — Basic Case

$ Input: startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]

› Output: 120

💡 Note: Select jobs 1 (1-3, profit 50) and job 4 (3-6, profit 70). Total profit = 50 + 70 = 120. Job 3 can't be selected because it overlaps with both selected jobs.

example_2.py — No Overlaps

$ Input: startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]

› Output: 150

💡 Note: Select jobs 1 (1-3, profit 20), 4 (4-6, profit 70), and 5 (6-9, profit 60). These don't overlap: 1-3, 4-6, 6-9. Total = 20 + 70 + 60 = 150.

example_3.py — Single Job

$ Input: startTime = [1], endTime = [2], profit = [50]

› Output: 50

💡 Note: Only one job available, so select it for profit 50.

Visualization

Tap to expand

Understanding the Visualization

Timeline Setup

Arrange all potential concerts on a timeline, showing their duration and profit

Smart Selection

Use binary search to quickly find which previous concerts don't conflict with each new option

Profit Maximization

For each concert, decide whether to book it (plus best previous combination) or skip it

Key Takeaway

🎯 Key Insight: By sorting concerts by end time and using binary search to find compatible previous bookings, we can efficiently build the optimal schedule that maximizes venue profit while avoiding conflicts.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for binary search in DP loop

⚡ Linearithmic

Space Complexity

O(n)

O(n) space for DP array and sorted jobs array

⚡ Linearithmic Space

Constraints

1 ≤ startTime.length == endTime.length == profit.length ≤ 5 * 10⁴
1 ≤ startTime[i] < endTime[i] ≤ 10⁹
1 ≤ profit[i] ≤ 10⁴
Jobs can start immediately when another ends (endTime[i] == startTime[j] is valid)

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 25

The optimal approach uses Dynamic Programming with Binary Search achieving O(n log n) time complexity. Sort jobs by end time, then for each job use binary search to efficiently find the latest non-conflicting previous job, building up the maximum profit incrementally with the recurrence: dp[i] = max(dp[i-1], profit[i] + dp[prev_compatible]).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming + Binary Search (Optimal)	O(n log n)	O(n)	Sort jobs by end time, use DP with binary search to find optimal non-conflicting combinations
Brute Force (Try All Combinations)	O(n * 2^n)	O(1)	Generate all possible job combinations and find the maximum profit among valid ones

Dynamic Programming + Binary Search (Optimal) — Algorithm Steps

Create job objects and sort by end time
For each job position, use binary search to find the latest non-conflicting previous job
Apply DP: dp[i] = max(dp[i-1], profit[i] + dp[prev_job])
Return the maximum profit from the last position

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by End Time

Arrange jobs chronologically by their end times

Binary Search

For each job, quickly find the latest non-conflicting previous job

DP Decision

Choose max between taking current job (with best previous) or skipping it

Code -

solution.c — C

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

typedef struct {
    int end, start, profit;
} Job;

int compare(const void *a, const void *b) {
    return ((Job*)a)->end - ((Job*)b)->end;
}

int binarySearch(Job* jobs, int i) {
    int left = 0, right = i - 1;
    int result = -1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (jobs[mid].end <= jobs[i].start) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return result;
}

int jobScheduling(int* startTime, int startTimeSize, int* endTime, int endTimeSize, int* profit, int profitSize) {
    int n = startTimeSize;
    if (n == 0) return 0;
    
    Job* jobs = (Job*)malloc(n * sizeof(Job));
    for (int i = 0; i < n; i++) {
        jobs[i] = (Job){endTime[i], startTime[i], profit[i]};
    }
    
    qsort(jobs, n, sizeof(Job), compare);
    
    int* dp = (int*)malloc(n * sizeof(int));
    dp[0] = jobs[0].profit;
    
    for (int i = 1; i < n; i++) {
        int profitWithout = dp[i-1];
        int profitWith = jobs[i].profit;
        int latestCompatible = binarySearch(jobs, i);
        if (latestCompatible != -1) {
            profitWith += dp[latestCompatible];
        }
        
        dp[i] = (profitWithout > profitWith) ? profitWithout : profitWith;
    }
    
    int result = dp[n-1];
    free(jobs);
    free(dp);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for binary search in DP loop

⚡ Linearithmic

Space Complexity

O(n)

O(n) space for DP array and sorted jobs array

⚡ Linearithmic Space

Constraints

1 ≤ startTime.length == endTime.length == profit.length ≤ 5 * 10⁴
1 ≤ startTime[i] < endTime[i] ≤ 10⁹
1 ≤ profit[i] ≤ 10⁴
Jobs can start immediately when another ends (endTime[i] == startTime[j] is valid)

73.9K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler