Reach a Meeting by Scheduled Trains

A timetable contains directed train rides. Ride i leaves city origins[i] at time departures[i], reaches city destinations[i] at time arrivals[i], and may be used at most once.
You begin in start at startTime. You may wait in any city for any nonnegative amount of time. You may board a ride when you are in its origin city at or before its departure time.
Return true if you can reach destination no later than meetingTime. Otherwise, return false.
A transfer is allowed when one ride arrives at the exact time that the next ride departs. If start already equals destination, reaching the meeting depends only on whether startTime is no later than meetingTime.

Function
canReachMeeting(origins: String[], departures: int[], destinations: String[], arrivals: int[], start: String, startTime: int, destination: String, meetingTime: int) → boolean

Examples
Example 1
origins = ["A","B","A"]
departures = [1,5,3]
destinations = ["B","C","C"]
arrivals = [4,7,10]
start = "A"
startTime = 0
destination = "C"
meetingTime = 8
return = true
Take the ride from A to B, arriving at 4, then take the ride from B to C, arriving at 7.
Example 2
origins = ["A","B","A"]
departures = [1,5,3]
destinations = ["B","C","C"]
arrivals = [4,7,10]
start = "A"
startTime = 0
destination = "C"
meetingTime = 6
return = false
The earliest possible arrival in C is time 7, which is after the meeting time.
Example 3
origins = ["A","B"]
departures = [2,5]
destinations = ["B","C"]
arrivals = [5,6]
start = "A"
startTime = 2
destination = "C"
meetingTime = 6
return = true
You board the first ride exactly at startTime. It arrives in B at time 5, allowing an exact-time transfer to the second ride.

Constraints
1 <= origins.length <= 2 * 10^5.
origins.length == departures.length == destinations.length == arrivals.length.
Every city name is nonempty and contains at most 30 letters or digits.
0 <= departures[i] <= arrivals[i] <= 10^9.
0 <= startTime, meetingTime <= 10^9.

The trick is to process rides in order of departure time and track the earliest arrival time per city. Sort rides by departure. Keep a map from city to earliest known arrival, seeded with start at startTime. For each ride, if its origin has an earliest time at or before the departure, you can board it, so update the destination's earliest time with the arrival. Because arrivals are never before departures, one sorted pass is enough. Final check: earliest[destination] <= meetingTime. The pitfalls are real. Handle start equal to destination first, where only startTime <= meetingTime matters. Use <= for boarding so exact transfers work. Don't build a full graph and run Dijkstra when a sort and a hash map do it. Zero-duration rides (departure equals arrival) can chain at the same timestamp, so tie-break order matters. If the live OA freezes you on that, StealthCoder is the hedge that keeps you moving. Complexity is O(n log n).

If you see this problem in your OA tomorrow, the play is to recognize the pattern in 30 seconds. StealthCoder buys you that recognition.