Maximum Earnings From Taxi - Practice Coding Problems

Maximum Earnings From Taxi - Problem

You're a taxi driver on a straight road with n numbered points (1 to n). Your goal is to drive from point 1 to point n while maximizing your earnings by strategically picking up passengers.

Each passenger is represented as [start, end, tip] where:

start: pickup point
end: dropoff point
tip: additional tip in dollars

For each ride, you earn: (end - start) + tip dollars

Key Rules:

🚗 You can only carry one passenger at a time
🚫 You cannot change direction (always move forward)
✅ You can drop off and pick up different passengers at the same point

Return the maximum dollars you can earn by optimally selecting passengers.

Input & Output

example_1.py — Basic Case

$ Input: n = 5, rides = [[2,5,4],[1,5,1],[4,6,2]]

› Output: 7

💡 Note: Pick up passenger 2 who tips 4 dollars. Earnings = 5-2+4 = 7. This is better than taking passenger 1 (earnings = 5-1+1 = 5) or passenger 3 (earnings = 6-4+2 = 4).

example_2.py — Multiple Non-overlapping

$ Input: n = 20, rides = [[1,6,1],[3,10,2],[10,12,3],[11,12,2],[12,15,2],[13,18,1]]

› Output: 20

💡 Note: Take rides [1,6,1], [10,12,3], and [12,15,2]. Total earnings: (6-1+1) + (12-10+3) + (15-12+2) = 6 + 5 + 5 = 16. Wait, let me recalculate: optimal is actually taking [3,10,2] + [12,15,2] + [13,18,1] = 9 + 5 + 6 = 20.

example_3.py — Single Ride

$ Input: n = 10, rides = [[5,8,3]]

› Output: 6

💡 Note: Only one ride available. Earnings = 8-5+3 = 6 dollars.

Visualization

Tap to expand

Understanding the Visualization

Sort by End Times

Sort all rides by their end times to process them in optimal order

Dynamic Programming

For each ride, decide: take it (plus best earnings before it started) or skip it

Binary Search

Quickly find the latest ride that doesn't overlap with the current one

Build Optimal Solution

Incrementally build the maximum earnings possible

Key Takeaway

🎯 Key Insight: This is a classic interval scheduling optimization problem. Sort intervals by end time, then use DP with binary search to efficiently find the best combination of non-overlapping rides.

Time & Space Complexity

Time Complexity

⏱️

O(2^m)

We try all 2^m possible combinations of m rides

✓ Linear Growth

Space Complexity

O(m)

Recursion stack depth and storage for current combination

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ rides.length ≤ 3 × 10⁴
rides[i].length == 3
1 ≤ start_i < end_i ≤ n
1 ≤ tip_i ≤ 10⁵
All start and end points are integers

Asked in

G Google 15 a Amazon 12 U Uber 25 L Lyft 18

The optimal approach uses Dynamic Programming with Binary Search. Sort rides by end time, then for each ride use binary search to find the latest non-overlapping previous ride. The DP recurrence is: dp[i] = max(take_current + dp[last_compatible], skip_current). Time complexity: O(m log m), Space: O(m).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^m)	O(m)	Generate all possible combinations of non-overlapping rides
Dynamic Programming + Binary Search	O(m log m)	O(m)	Sort rides by end time, use DP with binary search to find non-overlapping rides

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible subsets of rides
For each subset, check if all rides are non-overlapping
Calculate total earnings for valid subsets
Return the maximum earnings found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subsets

Use bit masks to generate all 2^m possible combinations of rides

Check Overlaps

For each combination, verify no rides overlap in time

Calculate Earnings

Sum up earnings for valid combinations

Track Maximum

Keep track of the highest earnings found

Code -

solution.c — C

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

bool isValidCombination(int** selected, int count) {
    for (int i = 0; i < count; i++) {
        for (int j = i + 1; j < count; j++) {
            if (!(selected[i][1] <= selected[j][0] || selected[j][1] <= selected[i][0])) {
                return false;
            }
        }
    }
    return true;
}

long long maxTaxiEarnings(int n, int** rides, int ridesSize, int* ridesColSize) {
    long long maxEarnings = 0;
    
    // Try all 2^ridesSize combinations
    for (int mask = 0; mask < (1 << ridesSize); mask++) {
        int** selected = malloc(ridesSize * sizeof(int*));
        int count = 0;
        long long total = 0;
        
        for (int i = 0; i < ridesSize; i++) {
            if (mask & (1 << i)) {
                selected[count++] = rides[i];
                total += rides[i][1] - rides[i][0] + rides[i][2];
            }
        }
        
        if (isValidCombination(selected, count)) {
            if (total > maxEarnings) {
                maxEarnings = total;
            }
        }
        
        free(selected);
    }
    
    return maxEarnings;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m)

We try all 2^m possible combinations of m rides

✓ Linear Growth

Space Complexity

O(m)

Recursion stack depth and storage for current combination

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
1 ≤ rides.length ≤ 3 × 10⁴
rides[i].length == 3
1 ≤ start_i < end_i ≤ n
1 ≤ tip_i ≤ 10⁵
All start and end points are integers

23.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler