Maximum Number of Events That Can Be Attended - Leetcode 1353

Author: kshitizsaini113

src/main/java/priorityqueue/maximum_events_that_can_be_attended/PriorityQueueSolution.java

@@ -0,0 +1,83 @@
+package priorityqueue.maximum_events_that_can_be_attended;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+/**
+ * Solves the "Maximum Number of Events That Can Be Attended" problem using a greedy approach
+ * with a min-priority queue.
+ *
+ * <p>The core idea is to iterate through each day and, on any given day, attend the available
+ * event that will end the soonest. This greedy choice ensures that we leave future days open
+ * for events that last longer.
+ *
+ * <p><b>Algorithm:</b>
+ * <ol>
+ *   <li>Sort the events by their start day. This allows us to process events chronologically.</li>
+ *   <li>Initialize a min-priority queue to store the end days of events that are currently available to attend.</li>
+ *   <li>Iterate through the days from the first possible start day to the last possible end day.</li>
+ *   <li>On each day, add all events that start on that day to the priority queue. The queue will store their end days.</li>
+ *   <li>Remove any events from the queue that have already ended (i.e., their end day is before the current day).</li>
+ *   <li>If there are any events in the queue, attend one. We greedily pick the one that finishes earliest
+ *   (the top of the min-queue), increase our attended events count, and move to the next day.</li>
+ * </ol>
+ *
+ * <p><b>Complexity Analysis:</b>
+ * <ul>
+ *   <li>Time Complexity: O(N log N), dominated by the initial sort of the events. The while loop processes each event
+ *   and day once, and each priority queue operation is O(log K), where K is the number of active events.
+ *   <li>Space Complexity: O(N) in the worst case, where the priority queue could hold all events if they all start on the same day.
+ * </ul>
+ *
+ * @see <a href="https://leetcode.com/problems/maximum-number-of-events-that-can-be-attended/">1353. Maximum Number of Events That Can Be Attended</a>
+ */
+public class PriorityQueueSolution {
+
+    /**
+     * Calculates the maximum number of events that can be attended.
+     *
+     * @param events A 2D array where {@code events[i] = [startDay, endDay]}.
+     * @return The maximum number of events that can be attended.
+     */
+    public int maxEvents(int[][] events) {
+        // Sort events by their start day to process them in order.
+        Arrays.sort(events, Comparator.comparingInt(a -> a[0]));
+
+        // A min-priority queue to store the end days of events that are currently available.
+        // The greedy choice is to always attend the event that finishes earliest.
+        Queue<Integer> queue = new PriorityQueue<>();
+
+        int day = 0;          // Current day
+        int index = 0;        // Pointer for the events array
+        int result = 0;       // Total number of events attended
+        int numberOfEvents = events.length;
+
+        // The main loop continues as long as there are events to process or events in the queue to attend.
+        while (index < numberOfEvents || !queue.isEmpty()) {
+            // If the queue is empty, we can fast-forward time to the start day of the next available event.
+            if (queue.isEmpty()) {
+                day = events[index][0];
+            }
+
+            // Add all events that start on the current day to the priority queue.
+            while (index < numberOfEvents && events[index][0] == day) {
+                queue.offer(events[index][1]);
+                index++;
+            }
+
+            // Attend the event that ends the soonest.
+            queue.poll();
+            result++;
+            day++; // Move to the next day.
+
+            // Clean up the queue by removing events that have already ended.
+            // An event with endDay < current day cannot be attended.
+            while (!queue.isEmpty() && queue.peek() < day) {
+                queue.poll();
+            }
+        }
+        return result;
+    }
+}

src/main/java/priorityqueue/maximum_events_that_can_be_attended/package-info.java

@@ -0,0 +1,24 @@
+/**
+ * This package contains a solution for the LeetCode problem:
+ * "1353. Maximum Number of Events That Can Be Attended".
+ *
+ * <p>Problem Statement:
+ * You are given an array of events where {@code events[i] = [startDayi, endDayi]}.
+ * Every event {@code i} starts at {@code startDayi} and ends at {@code endDayi}.
+ *
+ * <p>You can attend an event {@code i} on any day {@code d} where
+ * {@code startDayi <= d <= endDayi}. You can only attend one event at any given day {@code d}.
+ *
+ * <p>The goal is to return the maximum number of events you can attend.
+ *
+ * <p><b>Constraints:</b>
+ * <ul>
+ *   <li>{@code 1 <= events.length <= 10^5}</li>
+ *   <li>{@code events[i].length == 2}</li>
+ *   <li>{@code 1 <= startDayi <= endDayi <= 10^5}</li>
+ * </ul>
+ *
+ * @see <a href="https://leetcode.com/problems/maximum-number-of-events-that-can-be-attended/">
+ * 1353. Maximum Number of Events That Can Be Attended</a>
+ */
+package priorityqueue.maximum_events_that_can_be_attended;

src/main/java/priorityqueue/package-info.java

@@ -0,0 +1,9 @@
+/**
+ * This package contains implementations of the Priority Queue data structure.
+ *
+ * <p>A priority queue is an abstract data type that operates like a regular queue
+ * but with a twist: each element has an associated "priority". Elements with
+ * higher priority are served before elements with lower priority. If two elements
+ * share the same priority, their order is determined by their position in the queue.
+ */
+package priorityqueue;

src/test/java/priorityqueue/maximum_events_that_can_be_attended/PriorityQueueSolutionTest.java

@@ -0,0 +1,94 @@
+package priorityqueue.maximum_events_that_can_be_attended;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Unit tests for the {@link PriorityQueueSolution} class.
+ */
+class PriorityQueueSolutionTest {
+
+    private PriorityQueueSolution solution;
+
+    @BeforeEach
+    void setUp() {
+        solution = new PriorityQueueSolution();
+    }
+
+    @Test
+    void testLeetCodeExample1() {
+        int[][] events = {{1, 2}, {2, 3}, {3, 4}};
+        assertEquals(3, solution.maxEvents(events), "Should be able to attend all three sequential events.");
+    }
+
+    @Test
+    void testLeetCodeExample2() {
+        int[][] events = {{1, 2}, {2, 3}, {3, 4}, {1, 2}};
+        assertEquals(4, solution.maxEvents(events), "Should attend all four events by careful scheduling.");
+    }
+
+    @Test
+    void testComplexOverlap() {
+        int[][] events = {{1, 4}, {4, 4}, {2, 2}, {3, 4}, {1, 1}};
+        // Day 1: Attend {1,1}
+        // Day 2: Attend {2,2}
+        // Day 3: Attend {1,4} (available since day 1)
+        // Day 4: Attend {3,4} or {4,4}
+        assertEquals(4, solution.maxEvents(events), "Should correctly handle complex overlapping events.");
+    }
+
+    @Test
+    void testNoOverlapEvents() {
+        int[][] events = {{1, 2}, {4, 5}, {7, 8}};
+        assertEquals(3, solution.maxEvents(events), "Should attend all events when there is no overlap.");
+    }
+
+    @Test
+    void testFullOverlapOnSingleDay() {
+        int[][] events = {{1, 1}, {1, 1}, {1, 1}};
+        assertEquals(1, solution.maxEvents(events), "Should only attend one event if all are on the same day.");
+    }
+
+    @Test
+    void testIdenticalLongEvents() {
+        int[][] events = {{1, 5}, {1, 5}, {1, 5}};
+        // Day 1: Attend one {1,5}
+        // Day 2: Attend another {1,5}
+        // Day 3: Attend the last {1,5}
+        assertEquals(3, solution.maxEvents(events), "Should attend one of the identical events on each available day.");
+    }
+
+    @Test
+    void testEdgeCaseEmptyEvents() {
+        int[][] events = {};
+        assertEquals(0, solution.maxEvents(events), "Should return 0 for an empty array of events.");
+    }
+
+    @Test
+    void testEdgeCaseSingleEvent() {
+        int[][] events = {{10, 12}};
+        assertEquals(1, solution.maxEvents(events), "Should attend the single available event.");
+    }
+
+    @Test
+    void testEventsThatStartLate() {
+        int[][] events = {{100, 100}, {100, 101}};
+        // Day 100: Attend {100, 100}
+        // Day 101: Attend {100, 101}
+        assertEquals(2, solution.maxEvents(events), "Should handle events that start on a late day.");
+    }
+
+    @Test
+    void testGreedyChoiceIsOptimal() {
+        // On day 2, events {1,2} and {2,3} are available.
+        // The greedy choice is to attend {1,2} because it ends sooner.
+        // Day 1: Attend {1,1}
+        // Day 2: Attend {1,2} (ends today)
+        // Day 3: Attend {2,3}
+        // Day 4: Attend {3,4}
+        int[][] events = {{1, 2}, {1, 1}, {2, 3}, {3, 4}};
+        assertEquals(4, solution.maxEvents(events), "Should make the correct greedy choice to maximize events.");
+    }
+}