Added tasks 2398, 2399, 2400.

Author: javadev

README.md

@@ -1848,6 +1848,9 @@ implementation 'com.github.javadev:leetcode-in-java:1.13'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2400 |[Number of Ways to Reach a Position After Exactly k Steps](src/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/main/java/g2301_2400/s2399_check_distances_between_same_letters/Solution.java)| Easy | Array, String, Hash_Table | 1 | 99.88
+| 2398 |[Maximum Number of Robots Within Budget](src/main/java/g2301_2400/s2398_maximum_number_of_robots_within_budget/Solution.java)| Hard | Array, Binary_Search, Prefix_Sum, Sliding_Window, Queue, Heap_(Priority_Queue) | 15 | 99.75
 | 2397 |[Maximum Rows Covered by Columns](src/main/java/g2301_2400/s2397_maximum_rows_covered_by_columns/Solution.java)| Medium | Array, Matrix, Bit_Manipulation, Backtracking, Enumeration | 1 | 100.00
 | 2396 |[Strictly Palindromic Number](src/main/java/g2301_2400/s2396_strictly_palindromic_number/Solution.java)| Medium | Math, Two_Pointers, Brainteaser | 0 | 100.00
 | 2395 |[Find Subarrays With Equal Sum](src/main/java/g2301_2400/s2395_find_subarrays_with_equal_sum/Solution.java)| Easy | Array, Hash_Table | 0 | 100.00
@@ -1856,7 +1859,7 @@ implementation 'com.github.javadev:leetcode-in-java:1.13'
 | 2390 |[Removing Stars From a String](src/main/java/g2301_2400/s2390_removing_stars_from_a_string/Solution.java)| Medium | String, Stack, Simulation | 31 | 90.55
 | 2389 |[Longest Subsequence With Limited Sum](src/main/java/g2301_2400/s2389_longest_subsequence_with_limited_sum/Solution.java)| Easy | Array, Sorting, Greedy, Binary_Search, Prefix_Sum | 4 | 99.97
 | 2386 |[Find the K-Sum of an Array](src/main/java/g2301_2400/s2386_find_the_k_sum_of_an_array/Solution.java)| Hard | Array, Sorting, Heap_Priority_Queue | 75 | 100.00
-| 2385 |[Amount of Time for Binary Tree to Be Infected](src/main/java/g2301_2400/s2385_amount_of_time_for_binary_tree_to_be_infected/Solution.java)| Medium | Tree, Binary_Tree, Depth_First_Search, Breadth_First_Search | 20 | 100.00
+| 2385 |[Amount of Time for Binary Tree to Be Infected](src/main/java/g2301_2400/s2385_amount_of_time_for_binary_tree_to_be_infected/Solution.java)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 20 | 100.00
 | 2384 |[Largest Palindromic Number](src/main/java/g2301_2400/s2384_largest_palindromic_number/Solution.java)| Medium | String, Hash_Table, Greedy | 26 | 100.00
 | 2383 |[Minimum Hours of Training to Win a Competition](src/main/java/g2301_2400/s2383_minimum_hours_of_training_to_win_a_competition/Solution.java)| Easy | Array, Greedy | 0 | 100.00
 | 2382 |[Maximum Segment Sum After Removals](src/main/java/g2301_2400/s2382_maximum_segment_sum_after_removals/Solution.java)| Hard | Array, Prefix_Sum, Union_Find, Ordered_Set | 28 | 100.00

src/main/java/g2301_2400/s2398_maximum_number_of_robots_within_budget/Solution.java

@@ -0,0 +1,46 @@
+package g2301_2400.s2398_maximum_number_of_robots_within_budget;
+
+// #Hard #Array #Binary_Search #Prefix_Sum #Sliding_Window #Queue #Heap_(Priority_Queue)
+// #2022_09_19_Time_15_ms_(99.75%)_Space_105.9_MB_(85.13%)
+
+public class Solution {
+
+    // use sliding window to track the largest in a way that the sliding window only grows.
+    //   then the maximum size is the size of the sliding window at the end.
+    // if condition is met, we just grow the sliding window.
+    // if condition is not met, we shift the sliding window with the same size to the next position.
+    // e.g., if [0,3] is valid, next time we will try [0,4].
+    //       if [0,3] is invalid, next time we will try [1,4],
+    //         by adjusting the window to [1,3] first in the current round.
+    public int maximumRobots(int[] chargeTimes, int[] runningCosts, long budget) {
+        int n = chargeTimes.length;
+        // [front, end).
+        int[] deque = new int[n];
+        int front = 0;
+        int end = 0;
+        long sum = 0;
+        int left = 0;
+        int right = 0;
+        for (; right < n; ++right) {
+            // add right into the sliding window, so the window becomes [left, right].
+            // update sliding window max and window sum.
+            while (end - front > 0 && chargeTimes[deque[end - 1]] <= chargeTimes[right]) {
+                --end;
+            }
+            deque[end++] = right;
+            sum += runningCosts[right];
+            // if the condition is met in the window, do nothing,
+            // so the next window size will become one larger.
+            // if the condition is not met in the window, shrink one from the front,
+            // so the next window size will stay the same.
+            if (chargeTimes[deque[front]] + (right - left + 1) * sum > budget) {
+                while (end - front > 0 && deque[front] <= left) {
+                    ++front;
+                }
+                sum -= runningCosts[left];
+                ++left;
+            }
+        }
+        return right - left;
+    }
+}

src/main/java/g2301_2400/s2398_maximum_number_of_robots_within_budget/readme.md

@@ -0,0 +1,38 @@
+2398\. Maximum Number of Robots Within Budget
+
+Hard
+
+You have `n` robots. You are given two **0-indexed** integer arrays, `chargeTimes` and `runningCosts`, both of length `n`. The <code>i<sup>th</sup></code> robot costs `chargeTimes[i]` units to charge and costs `runningCosts[i]` units to run. You are also given an integer `budget`.
+
+The **total cost** of running `k` chosen robots is equal to `max(chargeTimes) + k * sum(runningCosts)`, where `max(chargeTimes)` is the largest charge cost among the `k` robots and `sum(runningCosts)` is the sum of running costs among the `k` robots.
+
+Return _the **maximum** number of **consecutive** robots you can run such that the total cost **does not** exceed_ `budget`.
+
+**Example 1:**
+
+**Input:** chargeTimes = [3,6,1,3,4], runningCosts = [2,1,3,4,5], budget = 25
+
+**Output:** 3
+
+**Explanation:**
+
+It is possible to run all individual and consecutive pairs of robots within budget.
+
+To obtain answer 3, consider the first 3 robots. The total cost will be max(3,6,1) + 3 \* sum(2,1,3) = 6 + 3 \* 6 = 24 which is less than 25.
+
+It can be shown that it is not possible to run more than 3 consecutive robots within budget, so we return 3. 
+
+**Example 2:**
+
+**Input:** chargeTimes = [11,12,19], runningCosts = [10,8,7], budget = 19
+
+**Output:** 0
+
+**Explanation:** No robot can be run that does not exceed the budget, so we return 0. 
+
+**Constraints:**
+
+*   `chargeTimes.length == runningCosts.length == n`
+*   <code>1 <= n <= 5 * 10<sup>4</sup></code>
+*   <code>1 <= chargeTimes[i], runningCosts[i] <= 10<sup>5</sup></code>
+*   <code>1 <= budget <= 10<sup>15</sup></code>

src/main/java/g2301_2400/s2399_check_distances_between_same_letters/Solution.java

@@ -0,0 +1,24 @@
+package g2301_2400.s2399_check_distances_between_same_letters;
+
+// #Easy #Array #String #Hash_Table #2022_09_19_Time_1_ms_(99.88%)_Space_43.8_MB_(22.33%)
+
+public class Solution {
+    public boolean checkDistances(String s, int[] distance) {
+        boolean[] seenFirstIndexYet = new boolean[26];
+        for (int idxIntoS = 0; idxIntoS < s.length(); ++idxIntoS) {
+            char c = s.charAt(idxIntoS);
+            if (!seenFirstIndexYet[c - 'a']) {
+                seenFirstIndexYet[c - 'a'] = true;
+                distance[c - 'a'] += idxIntoS;
+            } else {
+                // seenFirstIndexYet[c - 'a']
+                distance[c - 'a'] -= idxIntoS;
+                if (distance[c - 'a'] != -1) {
+                    // early return
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

src/main/java/g2301_2400/s2399_check_distances_between_same_letters/readme.md

@@ -0,0 +1,47 @@
+2399\. Check Distances Between Same Letters
+
+Easy
+
+You are given a **0-indexed** string `s` consisting of only lowercase English letters, where each letter in `s` appears **exactly** **twice**. You are also given a **0-indexed** integer array `distance` of length `26`.
+
+Each letter in the alphabet is numbered from `0` to `25` (i.e. `'a' -> 0`, `'b' -> 1`, `'c' -> 2`, ... , `'z' -> 25`).
+
+In a **well-spaced** string, the number of letters between the two occurrences of the <code>i<sup>th</sup></code> letter is `distance[i]`. If the <code>i<sup>th</sup></code> letter does not appear in `s`, then `distance[i]` can be **ignored**.
+
+Return `true` _if_ `s` _is a **well-spaced** string, otherwise return_ `false`.
+
+**Example 1:**
+
+**Input:** s = "abaccb", distance = [1,3,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
+
+**Output:** true
+
+**Explanation:**
+
+- 'a' appears at indices 0 and 2 so it satisfies distance[0] = 1.
+
+- 'b' appears at indices 1 and 5 so it satisfies distance[1] = 3.
+
+- 'c' appears at indices 3 and 4 so it satisfies distance[2] = 0.
+
+Note that distance[3] = 5, but since 'd' does not appear in s, it can be ignored.
+
+Return true because s is a well-spaced string. 
+
+**Example 2:**
+
+**Input:** s = "aa", distance = [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
+
+**Output:** false
+
+**Explanation:**
+
+- 'a' appears at indices 0 and 1 so there are zero letters between them. Because distance[0] = 1, s is not a well-spaced string. 
+
+**Constraints:**
+
+*   `2 <= s.length <= 52`
+*   `s` consists only of lowercase English letters.
+*   Each letter appears in `s` exactly twice.
+*   `distance.length == 26`
+*   `0 <= distance[i] <= 50`

src/main/java/g2301_2400/s2400_number_of_ways_to_reach_a_position_after_exactly_k_steps/Solution.java

@@ -0,0 +1,32 @@
+package g2301_2400.s2400_number_of_ways_to_reach_a_position_after_exactly_k_steps;
+
+// #Medium #Dynamic_Programming #Math #Combinatorics
+// #2022_09_19_Time_1_ms_(99.66%)_Space_41.7_MB_(91.83%)
+
+public class Solution {
+    private int mod = 1000000007;
+
+    public int numberOfWays(int startPos, int endPos, int k) {
+        if (Math.abs(endPos - startPos) > k) {
+            return 0;
+        }
+        if (Math.abs(endPos - startPos + k) % 2 != 0) {
+            return 0;
+        }
+        int t = endPos - startPos;
+        int right = (k + t) / 2;
+        int min = Math.min(right, k - right);
+        if (min == 0) {
+            return 1;
+        }
+        int[] rev = new int[min + 1];
+        rev[1] = 1;
+        int ans = k;
+        for (int i = 2; i <= min; i++) {
+            rev[i] = (int) ((long) (mod - mod / i) * (long) rev[mod % i] % mod);
+            ans = (int) ((long) ans * (long) (k - i + 1) % mod);
+            ans = (int) ((long) ans * (long) rev[i] % mod);
+        }
+        return ans;
+    }
+}

src/main/java/g2301_2400/s2400_number_of_ways_to_reach_a_position_after_exactly_k_steps/readme.md

@@ -0,0 +1,39 @@
+2400\. Number of Ways to Reach a Position After Exactly k Steps
+
+Medium
+
+You are given two **positive** integers `startPos` and `endPos`. Initially, you are standing at position `startPos` on an **infinite** number line. With one step, you can move either one position to the left, or one position to the right.
+
+Given a positive integer `k`, return _the number of **different** ways to reach the position_ `endPos` _starting from_ `startPos`_, such that you perform **exactly**_ `k` _steps_. Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+Two ways are considered different if the order of the steps made is not exactly the same.
+
+**Note** that the number line includes negative integers.
+
+**Example 1:**
+
+**Input:** startPos = 1, endPos = 2, k = 3
+
+**Output:** 3
+
+**Explanation:** We can reach position 2 from 1 in exactly 3 steps in three ways:
+
+- 1 -> 2 -> 3 -> 2.
+
+- 1 -> 2 -> 1 -> 2.
+
+- 1 -> 0 -> 1 -> 2.
+
+It can be proven that no other way is possible, so we return 3.
+
+**Example 2:**
+
+**Input:** startPos = 2, endPos = 5, k = 10
+
+**Output:** 0
+
+**Explanation:** It is impossible to reach position 5 from position 2 in exactly 10 steps. 
+
+**Constraints:**
+
+*   `1 <= startPos, endPos, k <= 1000`

src/test/java/g2301_2400/s2398_maximum_number_of_robots_within_budget/SolutionTest.java

@@ -0,0 +1,23 @@
+package g2301_2400.s2398_maximum_number_of_robots_within_budget;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void maximumRobots() {
+        assertThat(
+                new Solution()
+                        .maximumRobots(new int[] {3, 6, 1, 3, 4}, new int[] {2, 1, 3, 4, 5}, 25),
+                equalTo(3));
+    }
+
+    @Test
+    void maximumRobots2() {
+        assertThat(
+                new Solution().maximumRobots(new int[] {11, 12, 19}, new int[] {10, 8, 7}, 19),
+                equalTo(0));
+    }
+}

src/test/java/g2301_2400/s2399_check_distances_between_same_letters/SolutionTest.java

@@ -0,0 +1,34 @@
+package g2301_2400.s2399_check_distances_between_same_letters;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void checkDistances() {
+        assertThat(
+                new Solution()
+                        .checkDistances(
+                                "abaccb",
+                                new int[] {
+                                    1, 3, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                    0, 0, 0, 0, 0
+                                }),
+                equalTo(true));
+    }
+
+    @Test
+    void checkDistances2() {
+        assertThat(
+                new Solution()
+                        .checkDistances(
+                                "aa",
+                                new int[] {
+                                    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                    0, 0, 0, 0, 0
+                                }),
+                equalTo(false));
+    }
+}

src/test/java/g2301_2400/s2400_number_of_ways_to_reach_a_position_after_exactly_k_steps/SolutionTest.java

@@ -0,0 +1,33 @@
+package g2301_2400.s2400_number_of_ways_to_reach_a_position_after_exactly_k_steps;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void numberOfWays() {
+        assertThat(new Solution().numberOfWays(1, 2, 3), equalTo(3));
+    }
+
+    @Test
+    void numberOfWays2() {
+        assertThat(new Solution().numberOfWays(2, 5, 10), equalTo(0));
+    }
+
+    @Test
+    void numberOfWays3() {
+        assertThat(new Solution().numberOfWays(1, 10, 3), equalTo(0));
+    }
+
+    @Test
+    void numberOfWays4() {
+        assertThat(new Solution().numberOfWays(1, 1000, 999), equalTo(1));
+    }
+
+    @Test
+    void numberOfWays5() {
+        assertThat(new Solution().numberOfWays(272, 270, 6), equalTo(15));
+    }
+}