Added tasks 2407, 2409, 2410, 2411.

Author: javadev

README.md

@@ -1848,6 +1848,10 @@ implementation 'com.github.javadev:leetcode-in-java:1.14'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2411 |[Smallest Subarrays With Maximum Bitwise OR](src/main/java/g2401_2500/s2411_smallest_subarrays_with_maximum_bitwise_or/Solution.java)| |||
+| 2410 |[Maximum Matching of Players With Trainers](src/main/java/g2401_2500/s2410_maximum_matching_of_players_with_trainers/Solution.java)| Medium | Array, Sorting, Greedy, Two_Pointers | 28 | 98.31
+| 2409 |[Count Days Spent Together](src/main/java/g2401_2500/s2409_count_days_spent_together/Solution.java)| Easy | String, Math | 0 | 100.00
+| 2407 |[Longest Increasing Subsequence II](src/main/java/g2401_2500/s2407_longest_increasing_subsequence_ii/Solution.java)| Hard | Array, Dynamic_Programming, Divide_and_Conquer, Queue, Segment_Tree, Binary_Indexed_Tree, Monotonic_Queue | 24 | 99.21
 | 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

src/main/java/g2401_2500/s2407_longest_increasing_subsequence_ii/Solution.java

@@ -0,0 +1,60 @@
+package g2401_2500.s2407_longest_increasing_subsequence_ii;
+
+// #Hard #Array #Dynamic_Programming #Divide_and_Conquer #Queue #Segment_Tree #Binary_Indexed_Tree
+// #Monotonic_Queue #2022_10_24_Time_24_ms_(99.21%)_Space_50.3_MB_(98.08%)
+
+public class Solution {
+    private static class SegTree {
+        private int[] arr;
+        private int n;
+
+        public SegTree(int n) {
+            this.n = n;
+            arr = new int[2 * n];
+        }
+
+        public int query(int l, int r) {
+            l += n;
+            r += n;
+            int ans = 0;
+            while (l < r) {
+                if ((l & 1) == 1) {
+                    ans = Math.max(ans, arr[l]);
+                    l += 1;
+                }
+                if ((r & 1) == 1) {
+                    r -= 1;
+                    ans = Math.max(ans, arr[r]);
+                }
+                l = l >> 1;
+                r = r >> 1;
+            }
+            return ans;
+        }
+
+        public void update(int i, int val) {
+            i += n;
+            arr[i] = val;
+            while (i > 0) {
+                i = i >> 1;
+                arr[i] = Math.max(arr[2 * i], arr[2 * i + 1]);
+            }
+        }
+    }
+
+    public int lengthOfLIS(int[] nums, int k) {
+        int max = 0;
+        for (int n : nums) {
+            max = Math.max(max, n);
+        }
+        SegTree seg = new SegTree(max);
+        int ans = 0;
+        for (int n : nums) {
+            n -= 1;
+            int temp = seg.query(Math.max(0, n - k), n) + 1;
+            ans = Math.max(ans, temp);
+            seg.update(n, temp);
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,53 @@
+2407\. Longest Increasing Subsequence II
+
+Hard
+
+You are given an integer array `nums` and an integer `k`.
+
+Find the longest subsequence of `nums` that meets the following requirements:
+
+*   The subsequence is **strictly increasing** and
+*   The difference between adjacent elements in the subsequence is **at most** `k`.
+
+Return _the length of the **longest** **subsequence** that meets the requirements._
+
+A **subsequence** is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.
+
+**Example 1:**
+
+**Input:** nums = [4,2,1,4,3,4,5,8,15], k = 3
+
+**Output:** 5
+
+**Explanation:**
+
+The longest subsequence that meets the requirements is [1,3,4,5,8].
+
+The subsequence has a length of 5, so we return 5.
+
+Note that the subsequence [1,3,4,5,8,15] does not meet the requirements because 15 - 8 = 7 is larger than 3. 
+
+**Example 2:**
+
+**Input:** nums = [7,4,5,1,8,12,4,7], k = 5
+
+**Output:** 4
+
+**Explanation:**
+
+The longest subsequence that meets the requirements is [4,5,8,12].
+
+The subsequence has a length of 4, so we return 4. 
+
+**Example 3:**
+
+**Input:** nums = [1,5], k = 1
+
+**Output:** 1
+
+**Explanation:** The longest subsequence that meets the requirements is [1]. The subsequence has a length of 1, so we return 1. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i], k <= 10<sup>5</sup></code>

src/main/java/g2401_2500/s2409_count_days_spent_together/Solution.java

@@ -0,0 +1,35 @@
+package g2401_2500.s2409_count_days_spent_together;
+
+// #Easy #String #Math #2022_10_24_Time_0_ms_(100.00%)_Space_40.3_MB_(91.71%)
+
+public class Solution {
+    private int[] dates = new int[] {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+    public int countDaysTogether(
+            String arriveAlice, String leaveAlice, String arriveBob, String leaveBob) {
+        if (leaveAlice.compareTo(arriveBob) < 0 || leaveBob.compareTo(arriveAlice) < 0) {
+            return 0;
+        }
+        String end = leaveAlice.compareTo(leaveBob) <= 0 ? leaveAlice : leaveBob;
+        String start = arriveAlice.compareTo(arriveBob) <= 0 ? arriveBob : arriveAlice;
+        String[] starts = start.split("-");
+        String[] ends = end.split("-");
+        Integer startMonth = Integer.valueOf(starts[0]);
+        Integer endMonth = Integer.valueOf(ends[0]);
+        int res = 0;
+        if (startMonth.equals(endMonth)) {
+            res += (Integer.valueOf(ends[1]) - Integer.valueOf(starts[1]) + 1);
+            return res;
+        }
+        for (int i = startMonth; i <= endMonth; i++) {
+            if (i == endMonth) {
+                res += Integer.valueOf(ends[1]);
+            } else if (i == startMonth) {
+                res += dates[i] - Integer.valueOf(starts[1]) + 1;
+            } else {
+                res += dates[i];
+            }
+        }
+        return res;
+    }
+}

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

@@ -0,0 +1,33 @@
+2409\. Count Days Spent Together
+
+Easy
+
+Alice and Bob are traveling to Rome for separate business meetings.
+
+You are given 4 strings `arriveAlice`, `leaveAlice`, `arriveBob`, and `leaveBob`. Alice will be in the city from the dates `arriveAlice` to `leaveAlice` (**inclusive**), while Bob will be in the city from the dates `arriveBob` to `leaveBob` (**inclusive**). Each will be a 5-character string in the format `"MM-DD"`, corresponding to the month and day of the date.
+
+Return _the total number of days that Alice and Bob are in Rome together._
+
+You can assume that all dates occur in the **same** calendar year, which is **not** a leap year. Note that the number of days per month can be represented as: `[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]`.
+
+**Example 1:**
+
+**Input:** arriveAlice = "08-15", leaveAlice = "08-18", arriveBob = "08-16", leaveBob = "08-19"
+
+**Output:** 3
+
+**Explanation:** Alice will be in Rome from August 15 to August 18. Bob will be in Rome from August 16 to August 19. They are both in Rome together on August 16th, 17th, and 18th, so the answer is 3. 
+
+**Example 2:**
+
+**Input:** arriveAlice = "10-01", leaveAlice = "10-31", arriveBob = "11-01", leaveBob = "12-31"
+
+**Output:** 0
+
+**Explanation:** There is no day when Alice and Bob are in Rome together, so we return 0. 
+
+**Constraints:**
+
+*   All dates are provided in the format `"MM-DD"`.
+*   Alice and Bob's arrival dates are **earlier than or equal to** their leaving dates.
+*   The given dates are valid dates of a **non-leap** year.

src/main/java/g2401_2500/s2410_maximum_matching_of_players_with_trainers/Solution.java

@@ -0,0 +1,38 @@
+package g2401_2500.s2410_maximum_matching_of_players_with_trainers;
+
+// #Medium #Array #Sorting #Greedy #Two_Pointers
+// #2022_10_24_Time_28_ms_(98.31%)_Space_60.2_MB_(94.06%)
+
+import java.util.Arrays;
+
+@SuppressWarnings("java:S135")
+public class Solution {
+    public int matchPlayersAndTrainers(int[] players, int[] trainers) {
+        Arrays.sort(players);
+        Arrays.sort(trainers);
+        int i = 0;
+        int j = 0;
+        int count = 0;
+        i = 0;
+        while (i < players.length) {
+            while (trainers[j] < players[i]) {
+                j++;
+                if (j >= trainers.length) {
+                    break;
+                }
+            }
+            if (j >= trainers.length) {
+                break;
+            }
+            if (trainers[j] >= players[i]) {
+                count++;
+            }
+            i++;
+            j++;
+            if (j >= trainers.length || i >= players.length) {
+                break;
+            }
+        }
+        return count;
+    }
+}

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

@@ -0,0 +1,42 @@
+2410\. Maximum Matching of Players With Trainers
+
+Medium
+
+You are given a **0-indexed** integer array `players`, where `players[i]` represents the **ability** of the <code>i<sup>th</sup></code> player. You are also given a **0-indexed** integer array `trainers`, where `trainers[j]` represents the **training capacity** of the <code>j<sup>th</sup></code> trainer.
+
+The <code>i<sup>th</sup></code> player can **match** with the <code>j<sup>th</sup></code> trainer if the player's ability is **less than or equal to** the trainer's training capacity. Additionally, the <code>i<sup>th</sup></code> player can be matched with at most one trainer, and the <code>j<sup>th</sup></code> trainer can be matched with at most one player.
+
+Return _the **maximum** number of matchings between_ `players` _and_ `trainers` _that satisfy these conditions._
+
+**Example 1:**
+
+**Input:** players = [4,7,9], trainers = [8,2,5,8]
+
+**Output:** 2
+
+**Explanation:**
+
+One of the ways we can form two matchings is as follows:
+
+- players[0] can be matched with trainers[0] since 4 <= 8.
+
+- players[1] can be matched with trainers[3] since 7 <= 8.
+
+It can be proven that 2 is the maximum number of matchings that can be formed. 
+
+**Example 2:**
+
+**Input:** players = [1,1,1], trainers = [10]
+
+**Output:** 1
+
+**Explanation:**
+
+The trainer can be matched with any of the 3 players.
+
+Each player can only be matched with one trainer, so the maximum answer is 1. 
+
+**Constraints:**
+
+*   <code>1 <= players.length, trainers.length <= 10<sup>5</sup></code>
+*   <code>1 <= players[i], trainers[j] <= 10<sup>9</sup></code>

src/main/java/g2401_2500/s2411_smallest_subarrays_with_maximum_bitwise_or/Solution.java

@@ -0,0 +1,18 @@
+package g2401_2500.s2411_smallest_subarrays_with_maximum_bitwise_or;
+
+public class Solution {
+    public int[] smallestSubarrays(int[] nums) {
+        int[] res = new int[nums.length];
+        int[] bitPosition = new int[30];
+        for (int i = nums.length - 1; i >= 0; i--) {
+            res[i] = 1;
+            for (int j = 0; j < 30; j++) {
+                if ((nums[i] & (1 << j)) > 0) {
+                    bitPosition[j] = i;
+                }
+                res[i] = Math.max(res[i], bitPosition[j] - i + 1);
+            }
+        }
+        return res;
+    }
+}

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

@@ -0,0 +1,55 @@
+2411\. Smallest Subarrays With Maximum Bitwise OR
+
+Medium
+
+You are given a **0-indexed** array `nums` of length `n`, consisting of non-negative integers. For each index `i` from `0` to `n - 1`, you must determine the size of the **minimum sized** non-empty subarray of `nums` starting at `i` (**inclusive**) that has the **maximum** possible **bitwise OR**.
+
+*   In other words, let <code>B<sub>ij</sub></code> be the bitwise OR of the subarray `nums[i...j]`. You need to find the smallest subarray starting at `i`, such that bitwise OR of this subarray is equal to <code>max(B<sub>ik</sub>)</code> where `i <= k <= n - 1`.
+
+The bitwise OR of an array is the bitwise OR of all the numbers in it.
+
+Return _an integer array_ `answer` _of size_ `n` _where_ `answer[i]` _is the length of the **minimum** sized subarray starting at_ `i` _with **maximum** bitwise OR._
+
+A **subarray** is a contiguous non-empty sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [1,0,2,1,3]
+
+**Output:** [3,3,2,2,1]
+
+**Explanation:**
+
+The maximum possible bitwise OR starting at any index is 3.
+
+- Starting at index 0, the shortest subarray that yields it is [1,0,2].
+
+- Starting at index 1, the shortest subarray that yields the maximum bitwise OR is [0,2,1].
+
+- Starting at index 2, the shortest subarray that yields the maximum bitwise OR is [2,1].
+
+- Starting at index 3, the shortest subarray that yields the maximum bitwise OR is [1,3].
+
+- Starting at index 4, the shortest subarray that yields the maximum bitwise OR is [3].
+
+Therefore, we return [3,3,2,2,1]. 
+
+**Example 2:**
+
+**Input:** nums = [1,2]
+
+**Output:** [2,1]
+
+**Explanation:**
+
+Starting at index 0, the shortest subarray that yields the maximum bitwise OR is of length 2.
+
+Starting at index 1, the shortest subarray that yields the maximum bitwise OR is of length 1.
+
+Therefore, we return [2,1]. 
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>

src/test/java/g2401_2500/s2407_longest_increasing_subsequence_ii/SolutionTest.java

@@ -0,0 +1,24 @@
+package g2401_2500.s2407_longest_increasing_subsequence_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void lengthOfLIS() {
+        assertThat(
+                new Solution().lengthOfLIS(new int[] {4, 2, 1, 4, 3, 4, 5, 8, 15}, 3), equalTo(5));
+    }
+
+    @Test
+    void lengthOfLIS2() {
+        assertThat(new Solution().lengthOfLIS(new int[] {7, 4, 5, 1, 8, 12, 4, 7}, 5), equalTo(4));
+    }
+
+    @Test
+    void lengthOfLIS3() {
+        assertThat(new Solution().lengthOfLIS(new int[] {1, 5}, 1), equalTo(1));
+    }
+}