Added tasks 2106, 2108, 2109, 2110, 2111.

Author: ThanhNIT

src/main/java/g2101_2200/s2106_maximum_fruits_harvested_after_at_most_k_steps/Solution.java

@@ -0,0 +1,31 @@
+package g2101_2200.s2106_maximum_fruits_harvested_after_at_most_k_steps;
+
+// #Hard #Array #Binary_Search #Prefix_Sum #Sliding_Window
+// #2022_05_31_Time_27_ms_(48.57%)_Space_128.7_MB_(44.76%)
+
+public class Solution {
+    public int maxTotalFruits(int[][] fruits, int startPos, int k) {
+        int res = 0;
+        for (int left = 0, right = 0, sum = 0; right < fruits.length; right++) {
+            sum += fruits[right][1];
+            while (left <= right && !isValidRange(fruits[left][0], fruits[right][0], startPos, k)) {
+                sum -= fruits[left++][1];
+            }
+            res = Math.max(sum, res);
+        }
+
+        return res;
+    }
+
+    private boolean isValidRange(int leftPos, int rightPos, int startPos, int k) {
+        if (rightPos <= startPos) {
+            return startPos - leftPos <= k;
+        } else if (leftPos >= startPos) {
+            return rightPos - startPos <= k;
+        } else {
+            int left = startPos - leftPos;
+            int right = rightPos - startPos;
+            return left <= right ? left * 2 + right <= k : right * 2 + left <= k;
+        }
+    }
+}

src/main/java/g2101_2200/s2106_maximum_fruits_harvested_after_at_most_k_steps/readme.md

@@ -0,0 +1,64 @@
+2106\. Maximum Fruits Harvested After at Most K Steps
+
+Hard
+
+Fruits are available at some positions on an infinite x-axis. You are given a 2D integer array `fruits` where <code>fruits[i] = [position<sub>i</sub>, amount<sub>i</sub>]</code> depicts <code>amount<sub>i</sub></code> fruits at the position <code>position<sub>i</sub></code>. `fruits` is already **sorted** by <code>position<sub>i</sub></code> in **ascending order**, and each <code>position<sub>i</sub></code> is **unique**.
+
+You are also given an integer `startPos` and an integer `k`. Initially, you are at the position `startPos`. From any position, you can either walk to the **left or right**. It takes **one step** to move **one unit** on the x-axis, and you can walk **at most** `k` steps in total. For every position you reach, you harvest all the fruits at that position, and the fruits will disappear from that position.
+
+Return _the **maximum total number** of fruits you can harvest_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/11/21/1.png)
+
+**Input:** fruits = [[2,8],[6,3],[8,6]], startPos = 5, k = 4
+
+**Output:** 9
+
+**Explanation:** The optimal way is to: 
+
+- Move right to position 6 and harvest 3 fruits 
+
+- Move right to position 8 and harvest 6 fruits 
+  
+You moved 3 steps and harvested 3 + 6 = 9 fruits in total.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/11/21/2.png)
+
+**Input:** fruits = [[0,9],[4,1],[5,7],[6,2],[7,4],[10,9]], startPos = 5, k = 4
+
+**Output:** 14
+
+**Explanation:** You can move at most k = 4 steps, so you cannot reach position 0 nor 10. The optimal way is to: 
+
+- Harvest the 7 fruits at the starting position 5 
+
+- Move left to position 4 and harvest 1 fruit 
+
+- Move right to position 6 and harvest 2 fruits 
+
+- Move right to position 7 and harvest 4 fruits 
+  
+You moved 1 + 3 = 4 steps and harvested 7 + 1 + 2 + 4 = 14 fruits in total.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/11/21/3.png)
+
+**Input:** fruits = [[0,3],[6,4],[8,5]], startPos = 3, k = 2
+
+**Output:** 0
+
+**Explanation:** You can move at most k = 2 steps and cannot reach any position with fruits.
+
+**Constraints:**
+
+*   <code>1 <= fruits.length <= 10<sup>5</sup></code>
+*   `fruits[i].length == 2`
+*   <code>0 <= startPos, position<sub>i</sub> <= 2 * 10<sup>5</sup></code>
+*   <code>position<sub>i-1</sub> < position<sub>i</sub></code> for any `i > 0` (**0-indexed**)
+*   <code>1 <= amount<sub>i</sub> <= 10<sup>4</sup></code>
+*   <code>0 <= k <= 2 * 10<sup>5</sup></code>

src/main/java/g2101_2200/s2108_find_first_palindromic_string_in_the_array/Solution.java

@@ -0,0 +1,24 @@
+package g2101_2200.s2108_find_first_palindromic_string_in_the_array;
+
+// #Easy #Array #String #Two_Pointers #2022_05_31_Time_3_ms_(84.92%)_Space_50.1_MB_(69.85%)
+
+public class Solution {
+    public static boolean isPalindrome(String s) {
+        int len = s.length();
+        for (int i = 0, j = len - 1; i <= len / 2 && j >= len / 2; i++, j--) {
+            if (s.charAt(i) != s.charAt(j)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public String firstPalindrome(String[] words) {
+        for (String word : words) {
+            if (isPalindrome(word)) {
+                return word;
+            }
+        }
+        return "";
+    }
+}

src/main/java/g2101_2200/s2108_find_first_palindromic_string_in_the_array/readme.md

@@ -0,0 +1,37 @@
+2108\. Find First Palindromic String in the Array
+
+Easy
+
+Given an array of strings `words`, return _the first **palindromic** string in the array_. If there is no such string, return _an **empty string**_ `""`.
+
+A string is **palindromic** if it reads the same forward and backward.
+
+**Example 1:**
+
+**Input:** words = ["abc","car","ada","racecar","cool"]
+
+**Output:** "ada"
+
+**Explanation:** The first string that is palindromic is "ada". Note that "racecar" is also palindromic, but it is not the first.
+
+**Example 2:**
+
+**Input:** words = ["notapalindrome","racecar"]
+
+**Output:** "racecar"
+
+**Explanation:** The first and only string that is palindromic is "racecar".
+
+**Example 3:**
+
+**Input:** words = ["def","ghi"]
+
+**Output:** ""
+
+**Explanation:** There are no palindromic strings, so the empty string is returned.
+
+**Constraints:**
+
+*   `1 <= words.length <= 100`
+*   `1 <= words[i].length <= 100`
+*   `words[i]` consists only of lowercase English letters.

src/main/java/g2101_2200/s2109_adding_spaces_to_a_string/Solution.java

@@ -0,0 +1,25 @@
+package g2101_2200.s2109_adding_spaces_to_a_string;
+
+// #Medium #Array #String #Simulation #2022_05_31_Time_24_ms_(89.33%)_Space_94.5_MB_(48.03%)
+
+public class Solution {
+    public String addSpaces(String string, int[] spaces) {
+        char[] stringChars = new char[string.length() + spaces.length];
+        for (int i = 0; i < spaces.length; i++) {
+            stringChars[spaces[i] + i] = ' ';
+        }
+
+        int equivalentIndex = -1;
+        int i = 0;
+        while (i < string.length()) {
+            equivalentIndex++;
+            if (stringChars[equivalentIndex] == ' ') {
+                i--;
+            } else {
+                stringChars[equivalentIndex] = string.charAt(i);
+            }
+            i++;
+        }
+        return new String(stringChars);
+    }
+}

src/main/java/g2101_2200/s2109_adding_spaces_to_a_string/readme.md

@@ -0,0 +1,49 @@
+2109\. Adding Spaces to a String
+
+Medium
+
+You are given a **0-indexed** string `s` and a **0-indexed** integer array `spaces` that describes the indices in the original string where spaces will be added. Each space should be inserted **before** the character at the given index.
+
+*   For example, given `s = "EnjoyYourCoffee"` and `spaces = [5, 9]`, we place spaces before `'Y'` and `'C'`, which are at indices `5` and `9` respectively. Thus, we obtain `"Enjoy **Y**our **C**offee"`.
+
+Return _the modified string **after** the spaces have been added._
+
+**Example 1:**
+
+**Input:** s = "LeetcodeHelpsMeLearn", spaces = [8,13,15]
+
+**Output:** "Leetcode Helps Me Learn"
+
+**Explanation:** 
+
+The indices 8, 13, and 15 correspond to the underlined characters in "Leetcode**H**elps**M**e**L**earn". 
+
+We then place spaces before those characters.
+
+**Example 2:**
+
+**Input:** s = "icodeinpython", spaces = [1,5,7,9]
+
+**Output:** "i code in py thon"
+
+**Explanation:** 
+
+The indices 1, 5, 7, and 9 correspond to the underlined characters in "i**c**ode**i**n**p**y**t**hon". 
+
+We then place spaces before those characters.
+
+**Example 3:**
+
+**Input:** s = "spacing", spaces = [0,1,2,3,4,5,6]
+
+**Output:** " s p a c i n g"
+
+**Explanation:** We are also able to place spaces before the first character of the string.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 3 * 10<sup>5</sup></code>
+*   `s` consists only of lowercase and uppercase English letters.
+*   <code>1 <= spaces.length <= 3 * 10<sup>5</sup></code>
+*   `0 <= spaces[i] <= s.length - 1`
+*   All the values of `spaces` are **strictly increasing**.

src/main/java/g2101_2200/s2110_number_of_smooth_descent_periods_of_a_stock/Solution.java

@@ -0,0 +1,23 @@
+package g2101_2200.s2110_number_of_smooth_descent_periods_of_a_stock;
+
+// #Medium #Array #Dynamic_Programming #Math #2022_05_31_Time_3_ms_(77.27%)_Space_95.2_MB_(34.45%)
+
+public class Solution {
+    public long getDescentPeriods(int[] prices) {
+        long descendantCount = 0;
+        int previousCounts = 0;
+        for (int i = 0; i < prices.length - 1; i++) {
+            if (prices[i] - prices[i + 1] == 1) {
+                descendantCount++;
+                if (previousCounts > 0) {
+                    descendantCount += previousCounts;
+                }
+                previousCounts++;
+            } else {
+                previousCounts = 0;
+            }
+        }
+        descendantCount += prices.length;
+        return descendantCount;
+    }
+}

src/main/java/g2101_2200/s2110_number_of_smooth_descent_periods_of_a_stock/readme.md

@@ -0,0 +1,44 @@
+2110\. Number of Smooth Descent Periods of a Stock
+
+Medium
+
+You are given an integer array `prices` representing the daily price history of a stock, where `prices[i]` is the stock price on the <code>i<sup>th</sup></code> day.
+
+A **smooth descent period** of a stock consists of **one or more contiguous** days such that the price on each day is **lower** than the price on the **preceding day** by **exactly** `1`. The first day of the period is exempted from this rule.
+
+Return _the number of **smooth descent periods**_.
+
+**Example 1:**
+
+**Input:** prices = [3,2,1,4]
+
+**Output:** 7
+
+**Explanation:** There are 7 smooth descent periods: 
+
+[3], [2], [1], [4], [3,2], [2,1], and [3,2,1] 
+
+Note that a period with one day is a smooth descent period by the definition.
+
+**Example 2:**
+
+**Input:** prices = [8,6,7,7]
+
+**Output:** 4
+
+**Explanation:** There are 4 smooth descent periods: [8], [6], [7], and [7] 
+
+Note that [8,6] is not a smooth descent period as 8 - 6 ≠ 1.
+
+**Example 3:**
+
+**Input:** prices = [1]
+
+**Output:** 1
+
+**Explanation:** There is 1 smooth descent period: [1]
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 10<sup>5</sup></code>
+*   <code>1 <= prices[i] <= 10<sup>5</sup></code>

src/main/java/g2101_2200/s2111_minimum_operations_to_make_the_array_k_increasing/Solution.java

@@ -0,0 +1,45 @@
+package g2101_2200.s2111_minimum_operations_to_make_the_array_k_increasing;
+
+// #Hard #Array #Binary_Search #2022_05_31_Time_97_ms_(22.90%)_Space_123.6_MB_(54.96%)
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public int kIncreasing(int[] a, int k) {
+        int n = a.length;
+        int res = 0;
+        for (int s = 0; s < k; s++) {
+            List<Integer> dp = new ArrayList<>();
+            for (int i = s; i < n; i += k) {
+                if (!bsearch(dp, a[i])) {
+                    dp.add(a[i]);
+                }
+            }
+            res += dp.size();
+        }
+        return n - res;
+    }
+
+    private boolean bsearch(List<Integer> dp, int target) {
+        if (dp.isEmpty()) {
+            return false;
+        }
+        int lo = 0;
+        int hi = dp.size() - 1;
+        while (lo < hi) {
+            int mid = lo + (hi - lo) / 2;
+            if (dp.get(mid) <= target) {
+                lo = mid + 1;
+            } else {
+                hi = mid;
+            }
+        }
+
+        if (dp.get(lo) > target) {
+            dp.set(lo, target);
+            return true;
+        }
+        return false;
+    }
+}