Constraints

• 0 <= len(deliveries) <= 200000
• -10^9 <= startTime < endTime <= now <= 10^9
• driverId is an integer
• All times are integer minutes; 24 hours = 1440 minutes
• Delivery records may be unsorted and may contain duplicate or overlapping intervals for the same driver

Examples

Solution

def solution(deliveries, now):
    window = 24 * 60
    left = now - window

    intervals_by_driver = {}

    for driver_id, start, end in deliveries:
        # Delivery intervals are [start, end). The query window is (left, now].
        # With completed deliveries, an interval contributes iff end > left and start < now.
        if end <= left or start >= now:
            continue

        clipped_start = max(start, left)
        clipped_end = min(end, now)

        if clipped_start < clipped_end:
            intervals_by_driver.setdefault(driver_id, []).append((clipped_start, clipped_end))

    events = []

    # Merge intervals per driver so each driver contributes at most 1 to any instant.
    for intervals in intervals_by_driver.values():
        intervals.sort()
        cur_start, cur_end = intervals[0]

        for start, end in intervals[1:]:
            # Touching intervals can be merged: [a, b) and [b, c) keep the driver continuously counted as 1.
            if start <= cur_end:
                if end > cur_end:
                    cur_end = end
            else:
                events.append((cur_start, 1))
                events.append((cur_end, -1))
                cur_start, cur_end = start, end

        events.append((cur_start, 1))
        events.append((cur_end, -1))

    events.sort()

    current = 0
    best = 0
    i = 0

    while i < len(events):
        time = events[i][0]
        delta = 0

        while i < len(events) and events[i][0] == time:
            delta += events[i][1]
            i += 1

        current += delta
        if current > best:
            best = current

    return best

Time complexity: O(n log n), where n is the number of delivery records. Intervals are sorted per driver and sweep events are sorted globally.. Space complexity: O(n).

Hints

1. A same driver can have overlapping records, but must only be counted once. Consider clipping records to the 24-hour window, then merging intervals per driver first.
2. After each driver's intervals are disjoint, use a sweep line: interval starts add 1 and interval ends subtract 1. Group events with the same timestamp to respect half-open interval semantics.