Maximum Earnings From Taxi

Maximum Earnings From Taxi - Problem

There are n points on a road you are driving your taxi on. The n points on the road are labeled from 1 to n in the direction you are going, and you want to drive from point 1 to point n to make money by picking up passengers. You cannot change the direction of the taxi.

The passengers are represented by a 0-indexed 2D integer array rides, where rides[i] = [start_i, end_i, tip_i] denotes the ith passenger requesting a ride from point start_i to point end_i who is willing to give a tip_i dollar tip.

For each passenger i you pick up, you earn end_i - start_i + tip_i dollars. You may only drive at most one passenger at a time.

Given n and rides, return the maximum number of dollars you can earn by picking up the passengers optimally.

Note: You may drop off a passenger and pick up a different passenger at the same point.

Input & Output

Example 1 — Basic Multiple Rides

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

› Output: 7

💡 Note: Pick up the passenger from point 2 to point 5 with tip 4. Earnings = 5-2+4 = 7. The other ride overlaps so we can't take both.

Example 2 — Non-overlapping Rides

$ 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] for earnings 6+5+5=16, or find better combination [3,10,2] + [12,15,2] + [13,18,1] = 9+5+6=20

Example 3 — Single Ride

$ Input: n = 3, rides = [[1,3,0]]

› Output: 2

💡 Note: Only one ride available from point 1 to 3 with no tip. Earnings = 3-1+0 = 2

Constraints

1 ≤ n ≤ 10⁵
1 ≤ rides.length ≤ 3 × 10⁴
rides[i].length == 3
1 ≤ start_i < end_i ≤ n
1 ≤ tip_i ≤ 10⁵

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8 f Facebook 6

The key insight is to use dynamic programming after sorting rides by end time. For each ride, we choose between taking it (plus best earnings from non-overlapping previous rides) or skipping it. The optimal approach uses bottom-up DP with binary search to achieve O(n log n) time complexity and O(n) space complexity.

Common Approaches

✓ Two Pointers

⏱️ Time: N/A Space: N/A

Bottom-Up Dynamic Programming

⏱️ Time: O(n log n) Space: O(n)

Sort rides by end time, then for each ride, use binary search to find the latest non-overlapping ride. Build up the solution iteratively from smaller subproblems.

Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ) Space: O(n)

For each ride, we have two choices: take it or skip it. We recursively try both options for all rides, ensuring no overlaps, and return the maximum earnings possible.

Memoization - Top Down DP

⏱️ Time: O(n² log n) Space: O(n²)

Sort rides by start time, then use recursive approach with memoization. For each ride, we either take it (and find best solution after its end) or skip it.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

35.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