Constraints

• 1 <= len(calendars) == len(work_windows) <= 100000
• 0 <= total number of busy intervals across all calendars <= 200000
• 0 <= start < end <= 1440
• 0 <= workStart < workEnd <= 1440
• 1 <= d <= 1440

Examples

Solution

def solution(calendars, work_windows, d):
    import heapq

    if not calendars or not work_windows or len(calendars) != len(work_windows):
        return []

    common_start = max(window[0] for window in work_windows)
    common_end = min(window[1] for window in work_windows)

    if common_end - common_start < d:
        return []

    def normalize(calendar):
        intervals = []
        for interval in calendar:
            if len(interval) != 2:
                continue
            start, end = interval
            if end <= start:
                continue
            intervals.append((start, end))

        intervals.sort()

        merged = []
        for start, end in intervals:
            if not merged or start > merged[-1][1]:
                merged.append([start, end])
            elif end > merged[-1][1]:
                merged[-1][1] = end

        clipped = []
        for start, end in merged:
            start = max(start, common_start)
            end = min(end, common_end)
            if start < end:
                clipped.append([start, end])

        return clipped

    normalized = [normalize(calendar) for calendar in calendars]

    heap = []
    for person, calendar in enumerate(normalized):
        if calendar:
            start, end = calendar[0]
            heapq.heappush(heap, (start, end, person, 0))

    if not heap:
        return [common_start, common_start + d]

    current = common_start

    while heap:
        start, end, person, idx = heapq.heappop(heap)

        next_idx = idx + 1
        if next_idx < len(normalized[person]):
            next_start, next_end = normalized[person][next_idx]
            heapq.heappush(heap, (next_start, next_end, person, next_idx))

        if end <= current:
            continue

        if start - current >= d:
            return [current, current + d]

        current = max(current, end)

        while heap and heap[0][0] <= current:
            start2, end2, person2, idx2 = heapq.heappop(heap)

            next_idx2 = idx2 + 1
            if next_idx2 < len(normalized[person2]):
                next_start2, next_end2 = normalized[person2][next_idx2]
                heapq.heappush(heap, (next_start2, next_end2, person2, next_idx2))

            if end2 > current:
                current = end2

    if common_end - current >= d:
        return [current, current + d]

    return []

Time complexity: O(sum(m_i log m_i) + M log K), where m_i is the size of calendar i and M is the total number of busy intervals after preprocessing. If calendars are already sorted and non-overlapping, preprocessing drops to O(M).. Space complexity: O(M + K).

Hints

1. Any valid meeting must lie inside the intersection of all participants' working windows.
2. After clipping busy intervals to that common window, treat each calendar as a sorted stream and merge the K streams with a min-heap instead of flattening everything when K is large.