You are given a car with a fixed number of seats, denoted by an integer capacity. The car only travels in one direction — eastward — and does not make any U-turns.

You are also provided with an array, trips, where each element trips[i] $= [\text{numPassengers}_i, \text{from}_i, \text{to}_i]$ represents a group of $\text{numPassengers}_i$ that must be picked up at location $\text{from}_i$ and dropped off at location $\text{to}_i$. All locations are measured in kilometers east of the starting point.

Your task is to determine whether it is possible to complete all the trips without exceeding the car’s capacity at any point in time.

Return TRUE if all trips can be completed successfully, or FALSE otherwise.

Constraints:

• $1 \leq$ trips.length $\leq 1000$

• trips[i].length $== 3$

• $1 \leq \text{numPassengers}_i \leq 100$

• $0 \leq \text{from}_i < \text{to}_i \leq 1000$

• $1 \leq$ capacity $\leq 10^5$

The core intuition behind this solution is to simulate the journey of the car using a timeline, tracking when passengers get in and get out. This approach aligns with the merge intervals pattern, where we focus on events happening at specific points in time, rather than handling each trip separately in isolation. The idea is to accumulate and monitor the number of passengers in the car at any moment using a difference array (also known as a prefix sum technique).

In the context of this problem, each trip defines a passenger change over a specific interval — passengers are picked up at $\text{from}$ and dropped off at $\text{to}$. Instead of iterating over the entire interval (which is inefficient), we can track just the start and end of the interval using a fixed-size timeline array.

This strategy is built on two key observations:

1. Each trip contributes a net passenger change at exactly two locations:

   1. Increase at the pickup location ($\text{from}$)

   2. Decrease at the drop-off location ($\text{to}$)

2. The car’s capacity must never be exceeded at any point on the journey, so we monitor the cumulative passenger count as we move forward in time.

This strategy leverages the difference array pattern, which is a version of merge intervals. Rather than merging overlapping intervals explicitly, it simulates all trips together via a timeline of passenger changes.

Let’s break down the steps:

1. A list timestamp of size $1001$ (based on constraints) is created to track changes in passenger counts at each kilometer point.

2. For each trip $[\text{numPassengers}_i, \text{from}_i, \text{to}_i]$in trips:

   1. Add numPassengers at timestamp[$\text{from}_i$]

   2. Subtract numPassengers at timestamp[$\text{to}_i$]

This marks the start and end of each passenger interval without iterating over the full range.

3. To simulate the trip and track capacity, initialize a variable used_capacity = 0.

4. Iterate through the timestamp list, adding the passenger changes at each point. If at any point used_capacity > capacity, return FALSE immediately— the car is overloaded.

5. If the full timeline is processed without exceeding capacity, return TRUE, indicating that all trips can be accommodated.

Let’s look at the following illustration to get a better understanding of the solution: