Intervals and Event Sweep Pattern

When to use Intervals and Event Sweep

• You need to know the maximum number of intervals that overlap at any single point in time (peak concurrency).
• You are asked whether any two intervals from a set conflict — sort by start, then check adjacent pairs in one pass.
• You must insert a new interval into a sorted set of non-overlapping intervals and merge any neighbors it now touches.
• The problem asks for the minimum number of intervals to remove so the rest are non-overlapping (interval scheduling).
• You need the free time across multiple employees' schedules — merge all busy intervals first, then walk the gaps.

Template

function minMeetingRooms(intervals) {
  const starts = intervals.map(i => i[0]).sort((a, b) => a - b);
  const ends = intervals.map(i => i[1]).sort((a, b) => a - b);
  let rooms = 0;
  let maxRooms = 0;
  let s = 0;
  let e = 0;
  while (s < starts.length) {
    if (starts[s] < ends[e]) {
      rooms++;
      maxRooms = Math.max(maxRooms, rooms);
      s++;
    } else {
      rooms--;
      e++;
    }
  }
  return maxRooms;
}

Common mistakes

• Treating `[a, b]` and `[b, c]` as overlapping. Most LeetCode interval problems define touching endpoints as non-overlapping; double-check the prompt before deciding `<` vs `<=`.
• Sorting by start time on Non-overlapping Intervals. The canonical move is to sort by END time — sorting by start drops you into a harder DP. End-time sort is the greedy unlock.
• On Meeting Rooms II, using a single max-heap of end times but forgetting to push every new start (or to pop only when the current start is strictly greater than the heap top).
• Reading sweep events in the wrong order when start and end coincide. If an end event ties with a start, process the end first so the same room/agent can be reused.
• On Insert Interval, mutating the input array while iterating — collect output into a fresh array and return it, otherwise the indices drift mid-loop.