Added tasks 2402, 2404, 2405, 2406.

Author: javadev

README.md

@@ -1848,6 +1848,10 @@ implementation 'com.github.javadev:leetcode-in-java:1.14'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2406 |[Divide Intervals Into Minimum Number of Groups](src/main/java/g2401_2500/s2406_divide_intervals_into_minimum_number_of_groups/Solution.java)| Medium | Array, Sorting, Greedy, Two_Pointers, Prefix_Sum, Heap_Priority_Queue | 144 | 71.27
+| 2405 |[Optimal Partition of String](src/main/java/g2401_2500/s2405_optimal_partition_of_string/Solution.java)| Medium | String, Hash_Table, Greedy | 7 | 99.40
+| 2404 |[Most Frequent Even Element](src/main/java/g2401_2500/s2404_most_frequent_even_element/Solution.java)| Easy | Array, Hash_Table, Counting | 32 | 81.60
+| 2402 |[Meeting Rooms III](src/main/java/g2401_2500/s2402_meeting_rooms_iii/Solution.java)| Hard | Array, Sorting, Heap_Priority_Queue | 124 | 72.79
 | 2401 |[Longest Nice Subarray](src/main/java/g2401_2500/s2401_longest_nice_subarray/Solution.java)| Medium | Array, Bit_Manipulation, Sliding_Window | 4 | 87.45
 | 2400 |[Number of Ways to Reach a Position After Exactly k Steps](src.save/main/java/g2301_2400/s2400_number_of_ways_to_reach_a_position_after_exactly_k_steps/Solution.java)| Medium | Dynamic_Programming, Math, Combinatorics | 1 | 99.66
 | 2399 |[Check Distances Between Same Letters](src.save/main/java/g2301_2400/s2399_check_distances_between_same_letters/Solution.java)| Easy | Array, String, Hash_Table | 1 | 99.88

src/main/java/g2401_2500/s2402_meeting_rooms_iii/Solution.java

@@ -0,0 +1,48 @@
+package g2401_2500.s2402_meeting_rooms_iii;
+
+// #Hard #Array #Sorting #Heap_Priority_Queue
+// #2022_10_23_Time_124_ms_(72.79%)_Space_107_MB_(80.70%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int mostBooked(int n, int[][] meetings) {
+        int[] counts = new int[n];
+        long[] endTimes = new long[n];
+        Arrays.sort(meetings, (a, b) -> Integer.compare(a[0], b[0]));
+        for (int[] meeting : meetings) {
+            int id = findRoomId(endTimes, meeting[0]);
+            counts[id]++;
+            endTimes[id] = Math.max(endTimes[id], meeting[0]) + meeting[1] - meeting[0];
+        }
+        int res = 0;
+        long count = 0;
+        for (int i = 0; i < n; i++) {
+            if (counts[i] > count) {
+                count = counts[i];
+                res = i;
+            }
+        }
+        return res;
+    }
+
+    private int findRoomId(long[] endTimes, int start) {
+        int n = endTimes.length;
+        // Find the first one
+        for (int i = 0; i < n; i++) {
+            if (endTimes[i] <= start) {
+                return i;
+            }
+        }
+        // Only when non is not delayed, then we find the smallest one
+        int id = 0;
+        long min = Long.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            if (endTimes[i] < min) {
+                min = endTimes[i];
+                id = i;
+            }
+        }
+        return id;
+    }
+}

src/main/java/g2401_2500/s2402_meeting_rooms_iii/readme.md

@@ -0,0 +1,71 @@
+2402\. Meeting Rooms III
+
+Hard
+
+You are given an integer `n`. There are `n` rooms numbered from `0` to `n - 1`.
+
+You are given a 2D integer array `meetings` where <code>meetings[i] = [start<sub>i</sub>, end<sub>i</sub>]</code> means that a meeting will be held during the **half-closed** time interval <code>[start<sub>i</sub>, end<sub>i</sub>)</code>. All the values of <code>start<sub>i</sub></code> are **unique**.
+
+Meetings are allocated to rooms in the following manner:
+
+1.  Each meeting will take place in the unused room with the **lowest** number.
+2.  If there are no available rooms, the meeting will be delayed until a room becomes free. The delayed meeting should have the **same** duration as the original meeting.
+3.  When a room becomes unused, meetings that have an earlier original **start** time should be given the room.
+
+Return _the **number** of the room that held the most meetings._ If there are multiple rooms, return _the room with the **lowest** number._
+
+A **half-closed interval** `[a, b)` is the interval between `a` and `b` **including** `a` and **not including** `b`.
+
+**Example 1:**
+
+**Input:** n = 2, meetings = [[0,10],[1,5],[2,7],[3,4]]
+
+**Output:** 0
+
+**Explanation:**
+
+- At time 0, both rooms are not being used. The first meeting starts in room 0.
+
+- At time 1, only room 1 is not being used. The second meeting starts in room 1.
+
+- At time 2, both rooms are being used. The third meeting is delayed.
+
+- At time 3, both rooms are being used. The fourth meeting is delayed.
+
+- At time 5, the meeting in room 1 finishes. The third meeting starts in room 1 for the time period [5,10).
+
+- At time 10, the meetings in both rooms finish. The fourth meeting starts in room 0 for the time period [10,11).
+
+Both rooms 0 and 1 held 2 meetings, so we return 0. 
+
+**Example 2:**
+
+**Input:** n = 3, meetings = [[1,20],[2,10],[3,5],[4,9],[6,8]]
+
+**Output:** 1
+
+**Explanation:**
+
+- At time 1, all three rooms are not being used. The first meeting starts in room 0.
+
+- At time 2, rooms 1 and 2 are not being used. The second meeting starts in room 1.
+
+- At time 3, only room 2 is not being used. The third meeting starts in room 2.
+
+- At time 4, all three rooms are being used. The fourth meeting is delayed.
+
+- At time 5, the meeting in room 2 finishes. The fourth meeting starts in room 2 for the time period [5,10).
+
+- At time 6, all three rooms are being used. The fifth meeting is delayed.
+
+- At time 10, the meetings in rooms 1 and 2 finish. The fifth meeting starts in room 1 for the time period [10,12).
+
+Room 0 held 1 meeting while rooms 1 and 2 each held 2 meetings, so we return 1. 
+
+**Constraints:**
+
+*   `1 <= n <= 100`
+*   <code>1 <= meetings.length <= 10<sup>5</sup></code>
+*   `meetings[i].length == 2`
+*   <code>0 <= start<sub>i</sub> < end<sub>i</sub> <= 5 * 10<sup>5</sup></code>
+*   All the values of <code>start<sub>i</sub></code> are **unique**.

src/main/java/g2401_2500/s2404_most_frequent_even_element/Solution.java

@@ -0,0 +1,28 @@
+package g2401_2500.s2404_most_frequent_even_element;
+
+// #Easy #Array #Hash_Table #Counting #2022_10_23_Time_32_ms_(81.60%)_Space_56.5_MB_(79.42%)
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution {
+    public int mostFrequentEven(int[] nums) {
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        int mostFrequent = Integer.MAX_VALUE;
+        int maxFrequency = 0;
+        for (int num : nums) {
+            if ((num & 1) == 0) {
+                maxFrequency =
+                        Math.max(
+                                maxFrequency,
+                                frequencyMap.compute(num, (n, freq) -> freq == null ? 1 : ++freq));
+            }
+        }
+        for (Map.Entry<Integer, Integer> entry : frequencyMap.entrySet()) {
+            if (entry.getValue() == maxFrequency) {
+                mostFrequent = Math.min(mostFrequent, entry.getKey());
+            }
+        }
+        return mostFrequent == Integer.MAX_VALUE ? -1 : mostFrequent;
+    }
+}

src/main/java/g2401_2500/s2404_most_frequent_even_element/readme.md

@@ -0,0 +1,40 @@
+2404\. Most Frequent Even Element
+
+Easy
+
+Given an integer array `nums`, return _the most frequent even element_.
+
+If there is a tie, return the **smallest** one. If there is no such element, return `-1`.
+
+**Example 1:**
+
+**Input:** nums = [0,1,2,2,4,4,1]
+
+**Output:** 2
+
+**Explanation:**
+
+The even elements are 0, 2, and 4. Of these, 2 and 4 appear the most.
+
+We return the smallest one, which is 2.
+
+**Example 2:**
+
+**Input:** nums = [4,4,4,9,2,4]
+
+**Output:** 4
+
+**Explanation:** 4 is the even element appears the most. 
+
+**Example 3:**
+
+**Input:** nums = [29,47,21,41,13,37,25,7]
+
+**Output:** -1
+
+**Explanation:** There is no even element. 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 2000`
+*   <code>0 <= nums[i] <= 10<sup>5</sup></code>

src/main/java/g2401_2500/s2405_optimal_partition_of_string/Solution.java

@@ -0,0 +1,18 @@
+package g2401_2500.s2405_optimal_partition_of_string;
+
+// #Medium #String #Hash_Table #Greedy #2022_10_23_Time_7_ms_(99.40%)_Space_43.3_MB_(91.63%)
+
+public class Solution {
+    public int partitionString(String s) {
+        int count = 1;
+        boolean[] arr = new boolean[26];
+        for (char c : s.toCharArray()) {
+            if (arr[c - 'a']) {
+                count++;
+                arr = new boolean[26];
+            }
+            arr[c - 'a'] = true;
+        }
+        return count;
+    }
+}

src/main/java/g2401_2500/s2405_optimal_partition_of_string/readme.md

@@ -0,0 +1,36 @@
+2405\. Optimal Partition of String
+
+Medium
+
+Given a string `s`, partition the string into one or more **substrings** such that the characters in each substring are **unique**. That is, no letter appears in a single substring more than **once**.
+
+Return _the **minimum** number of substrings in such a partition._
+
+Note that each character should belong to exactly one substring in a partition.
+
+**Example 1:**
+
+**Input:** s = "abacaba"
+
+**Output:** 4
+
+**Explanation:**
+
+Two possible partitions are ("a","ba","cab","a") and ("ab","a","ca","ba").
+
+It can be shown that 4 is the minimum number of substrings needed. 
+
+**Example 2:**
+
+**Input:** s = "ssssss"
+
+**Output:** 6
+
+**Explanation:**
+
+The only valid partition is ("s","s","s","s","s","s"). 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of only English lowercase letters.

src/main/java/g2401_2500/s2406_divide_intervals_into_minimum_number_of_groups/Solution.java

@@ -0,0 +1,25 @@
+package g2401_2500.s2406_divide_intervals_into_minimum_number_of_groups;
+
+// #Medium #Array #Sorting #Greedy #Two_Pointers #Prefix_Sum #Heap_Priority_Queue
+// #2022_10_23_Time_144_ms_(71.27%)_Space_151.1_MB_(13.30%)
+
+public class Solution {
+    public int minGroups(int[][] intervals) {
+        int maxElement = 0;
+        for (int[] i : intervals) {
+            maxElement = Math.max(maxElement, i[0]);
+            maxElement = Math.max(maxElement, i[1]);
+        }
+        long[] prefixSum = new long[maxElement + 2];
+        for (int[] i : intervals) {
+            prefixSum[i[0]] += 1;
+            prefixSum[i[1] + 1] -= 1;
+        }
+        long ans = 0;
+        for (int i = 1; i <= maxElement + 1; i++) {
+            prefixSum[i] += prefixSum[i - 1];
+            ans = Math.max(ans, prefixSum[i]);
+        }
+        return (int) ans;
+    }
+}

src/main/java/g2401_2500/s2406_divide_intervals_into_minimum_number_of_groups/readme.md

@@ -0,0 +1,41 @@
+2406\. Divide Intervals Into Minimum Number of Groups
+
+Medium
+
+You are given a 2D integer array `intervals` where <code>intervals[i] = [left<sub>i</sub>, right<sub>i</sub>]</code> represents the **inclusive** interval <code>[left<sub>i</sub>, right<sub>i</sub>]</code>.
+
+You have to divide the intervals into one or more **groups** such that each interval is in **exactly** one group, and no two intervals that are in the same group **intersect** each other.
+
+Return _the **minimum** number of groups you need to make_.
+
+Two intervals **intersect** if there is at least one common number between them. For example, the intervals `[1, 5]` and `[5, 8]` intersect.
+
+**Example 1:**
+
+**Input:** intervals = [[5,10],[6,8],[1,5],[2,3],[1,10]]
+
+**Output:** 3
+
+**Explanation:** We can divide the intervals into the following groups:
+
+- Group 1: [1, 5], [6, 8].
+
+- Group 2: [2, 3], [5, 10].
+
+- Group 3: [1, 10].
+
+It can be proven that it is not possible to divide the intervals into fewer than 3 groups. 
+
+**Example 2:**
+
+**Input:** intervals = [[1,3],[5,6],[8,10],[11,13]]
+
+**Output:** 1
+
+**Explanation:** None of the intervals overlap, so we can put all of them in one group. 
+
+**Constraints:**
+
+*   <code>1 <= intervals.length <= 10<sup>5</sup></code>
+*   `intervals[i].length == 2`
+*   <code>1 <= left<sub>i</sub> <= right<sub>i</sub> <= 10<sup>6</sup></code>

src/test/java/g2401_2500/s2402_meeting_rooms_iii/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2401_2500.s2402_meeting_rooms_iii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void mostBooked() {
+        assertThat(
+                new Solution().mostBooked(2, new int[][] {{0, 10}, {1, 5}, {2, 7}, {3, 4}}),
+                equalTo(0));
+    }
+
+    @Test
+    void mostBooked2() {
+        assertThat(
+                new Solution()
+                        .mostBooked(3, new int[][] {{1, 20}, {2, 10}, {3, 5}, {4, 9}, {6, 8}}),
+                equalTo(1));
+    }
+}