Added tasks 2554-2559

Author: ThanhNIT

src/main/java/g2501_2600/s2554_maximum_number_of_integers_to_choose_from_a_range_i/Solution.java

@@ -0,0 +1,25 @@
+package g2501_2600.s2554_maximum_number_of_integers_to_choose_from_a_range_i;
+
+// #Medium #Array #Hash_Table #Sorting #Greedy #Binary_Search
+// #2023_08_19_Time_4_ms_(100.00%)_Space_44.9_MB_(17.88%)
+
+public class Solution {
+    public int maxCount(int[] banned, int n, int maxSum) {
+        boolean[] arr = new boolean[10002];
+        for (int j : banned) {
+            arr[j] = true;
+        }
+        int sum = 0;
+        int count = 0;
+        for (int i = 1; i <= n; i++) {
+            if (!arr[i]) {
+                sum += i;
+                if (sum > maxSum) {
+                    return count;
+                }
+                count++;
+            }
+        }
+        return count;
+    }
+}

src/main/java/g2501_2600/s2554_maximum_number_of_integers_to_choose_from_a_range_i/readme.md

@@ -0,0 +1,50 @@
+2554\. Maximum Number of Integers to Choose From a Range I
+
+Medium
+
+You are given an integer array `banned` and two integers `n` and `maxSum`. You are choosing some number of integers following the below rules:
+
+*   The chosen integers have to be in the range `[1, n]`.
+*   Each integer can be chosen **at most once**.
+*   The chosen integers should not be in the array `banned`.
+*   The sum of the chosen integers should not exceed `maxSum`.
+
+Return _the **maximum** number of integers you can choose following the mentioned rules_.
+
+**Example 1:**
+
+**Input:** banned = [1,6,5], n = 5, maxSum = 6
+
+**Output:** 2
+
+**Explanation:**
+
+You can choose the integers 2 and 4.
+
+2 and 4 are from the range [1, 5], both did not appear in banned, and their sum is 6, which did not exceed maxSum.
+
+**Example 2:**
+
+**Input:** banned = [1,2,3,4,5,6,7], n = 8, maxSum = 1
+
+**Output:** 0
+
+**Explanation:**
+
+You cannot choose any integer while following the mentioned conditions.
+
+**Example 3:**
+
+**Input:** banned = [11], n = 7, maxSum = 50
+
+**Output:** 7
+
+**Explanation:**
+
+You can choose the integers 1, 2, 3, 4, 5, 6, and 7. They are from the range [1, 7], all did not appear in banned, and their sum is 28, which did not exceed maxSum.
+
+**Constraints:**
+
+*   <code>1 <= banned.length <= 10<sup>4</sup></code>
+*   <code>1 <= banned[i], n <= 10<sup>4</sup></code>
+*   <code>1 <= maxSum <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2555_maximize_win_from_two_segments/Solution.java

@@ -0,0 +1,22 @@
+package g2501_2600.s2555_maximize_win_from_two_segments;
+
+// #Medium #Array #Binary_Search #Sliding_Window
+// #2023_08_19_Time_5_ms_(90.10%)_Space_55.4_MB_(45.54%)
+
+public class Solution {
+    public int maximizeWin(int[] a, int k) {
+        int j = 0;
+        int i;
+        int n = a.length;
+        int[] dp = new int[n + 1];
+        int ans = 0;
+        for (i = 0; i < a.length; i++) {
+            while (a[i] - a[j] > k) {
+                j++;
+            }
+            dp[i + 1] = Math.max(dp[i], i - j + 1);
+            ans = Math.max(ans, dp[j] + i - j + 1);
+        }
+        return ans;
+    }
+}

src/main/java/g2501_2600/s2555_maximize_win_from_two_segments/readme.md

@@ -0,0 +1,38 @@
+2555\. Maximize Win From Two Segments
+
+Medium
+
+There are some prizes on the **X-axis**. You are given an integer array `prizePositions` that is **sorted in non-decreasing order**, where `prizePositions[i]` is the position of the <code>i<sup>th</sup></code> prize. There could be different prizes at the same position on the line. You are also given an integer `k`.
+
+You are allowed to select two segments with integer endpoints. The length of each segment must be `k`. You will collect all prizes whose position falls within at least one of the two selected segments (including the endpoints of the segments). The two selected segments may intersect.
+
+*   For example if `k = 2`, you can choose segments `[1, 3]` and `[2, 4]`, and you will win any prize i that satisfies `1 <= prizePositions[i] <= 3` or `2 <= prizePositions[i] <= 4`.
+
+Return _the **maximum** number of prizes you can win if you choose the two segments optimally_.
+
+**Example 1:**
+
+**Input:** prizePositions = [1,1,2,2,3,3,5], k = 2
+
+**Output:** 7
+
+**Explanation:**
+
+In this example, you can win all 7 prizes by selecting two segments [1, 3] and [3, 5].
+
+**Example 2:**
+
+**Input:** prizePositions = [1,2,3,4], k = 0
+
+**Output:** 2
+
+**Explanation:**
+
+For this example, **one choice** for the segments is `[3, 3]` and `[4, 4],` and you will be able to get `2` prizes.
+
+**Constraints:**
+
+*   <code>1 <= prizePositions.length <= 10<sup>5</sup></code>
+*   <code>1 <= prizePositions[i] <= 10<sup>9</sup></code>
+*   <code>0 <= k <= 10<sup>9</sup></code>
+*   `prizePositions` is sorted in non-decreasing order.

src/main/java/g2501_2600/s2556_disconnect_path_in_a_binary_matrix_by_at_most_one_flip/Solution.java

@@ -0,0 +1,30 @@
+package g2501_2600.s2556_disconnect_path_in_a_binary_matrix_by_at_most_one_flip;
+
+// #Medium #Array #Dynamic_Programming #Depth_First_Search #Breadth_First_Search #Matrix
+// #2023_08_19_Time_0_ms_(100.00%)_Space_54.4_MB_(97.73%)
+
+public class Solution {
+    private int n;
+    private int m;
+
+    public boolean isPossibleToCutPath(int[][] g) {
+        n = g.length;
+        m = g[0].length;
+        if (!dfs(0, 0, g)) {
+            return true;
+        }
+        g[0][0] = 1;
+        return !dfs(0, 0, g);
+    }
+
+    private boolean dfs(int r, int c, int[][] g) {
+        if (r == n - 1 && c == m - 1) {
+            return true;
+        }
+        if (r == n || c == m || g[r][c] == 0) {
+            return false;
+        }
+        g[r][c] = 0;
+        return dfs(r, c + 1, g) || dfs(r + 1, c, g);
+    }
+}

src/main/java/g2501_2600/s2556_disconnect_path_in_a_binary_matrix_by_at_most_one_flip/readme.md

@@ -0,0 +1,44 @@
+2556\. Disconnect Path in a Binary Matrix by at Most One Flip
+
+Medium
+
+You are given a **0-indexed** `m x n` **binary** matrix `grid`. You can move from a cell `(row, col)` to any of the cells `(row + 1, col)` or `(row, col + 1)` that has the value `1`. The matrix is **disconnected** if there is no path from `(0, 0)` to `(m - 1, n - 1)`.
+
+You can flip the value of **at most one** (possibly none) cell. You **cannot flip** the cells `(0, 0)` and `(m - 1, n - 1)`.
+
+Return `true` _if it is possible to make the matrix disconnect or_ `false` _otherwise_.
+
+**Note** that flipping a cell changes its value from `0` to `1` or from `1` to `0`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/12/07/yetgrid2drawio.png)
+
+**Input:** grid = [[1,1,1],[1,0,0],[1,1,1]]
+
+**Output:** true
+
+**Explanation:**
+
+We can change the cell shown in the diagram above. There is no path from (0, 0) to (2, 2) in the resulting grid.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/12/07/yetgrid3drawio.png)
+
+**Input:** grid = [[1,1,1],[1,0,1],[1,1,1]]
+
+**Output:** false
+
+**Explanation:**
+
+It is not possible to change at most one cell such that there is not path from (0, 0) to (2, 2).
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 1000`
+*   <code>1 <= m * n <= 10<sup>5</sup></code>
+*   `grid[i][j]` is either `0` or `1`.
+*   `grid[0][0] == grid[m - 1][n - 1] == 1`

src/main/java/g2501_2600/s2558_take_gifts_from_the_richest_pile/Solution.java

@@ -0,0 +1,26 @@
+package g2501_2600.s2558_take_gifts_from_the_richest_pile;
+
+// #Easy #Array #Heap_Priority_Queue #Simulation
+// #2023_08_19_Time_5_ms_(97.80%)_Space_41.8_MB_(25.67%)
+
+import java.util.PriorityQueue;
+
+public class Solution {
+    public long pickGifts(int[] gifts, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> (b - a));
+        long res = 0;
+        for (int gift : gifts) {
+            pq.add(gift);
+        }
+        while (!pq.isEmpty() && k > 0) {
+            long val = pq.poll();
+            int newVal = (int) Math.sqrt(val);
+            pq.add(newVal);
+            k--;
+        }
+        while (!pq.isEmpty()) {
+            res += pq.poll();
+        }
+        return res;
+    }
+}

src/main/java/g2501_2600/s2558_take_gifts_from_the_richest_pile/readme.md

@@ -0,0 +1,46 @@
+2558\. Take Gifts From the Richest Pile
+
+Easy
+
+You are given an integer array `gifts` denoting the number of gifts in various piles. Every second, you do the following:
+
+*   Choose the pile with the maximum number of gifts.
+*   If there is more than one pile with the maximum number of gifts, choose any.
+*   Leave behind the floor of the square root of the number of gifts in the pile. Take the rest of the gifts.
+
+Return _the number of gifts remaining after_ `k` _seconds._
+
+**Example 1:**
+
+**Input:** gifts = [25,64,9,4,100], k = 4
+
+**Output:** 29
+
+**Explanation:** The gifts are taken in the following way: 
+
+- In the first second, the last pile is chosen and 10 gifts are left behind. 
+- Then the second pile is chosen and 8 gifts are left behind. 
+- After that the first pile is chosen and 5 gifts are left behind. 
+- Finally, the last pile is chosen again and 3 gifts are left behind. 
+
+The final remaining gifts are [5,8,9,4,3], so the total number of gifts remaining is 29.
+
+**Example 2:**
+
+**Input:** gifts = [1,1,1,1], k = 4
+
+**Output:** 4
+
+**Explanation:** 
+
+In this case, regardless which pile you choose, you have to leave behind 1 gift in each pile. 
+
+That is, you can't take any pile with you. 
+
+So, the total gifts remaining are 4.
+
+**Constraints:**
+
+*   <code>1 <= gifts.length <= 10<sup>3</sup></code>
+*   <code>1 <= gifts[i] <= 10<sup>9</sup></code>
+*   <code>1 <= k <= 10<sup>3</sup></code>

src/main/java/g2501_2600/s2559_count_vowel_strings_in_ranges/Solution.java

@@ -0,0 +1,37 @@
+package g2501_2600.s2559_count_vowel_strings_in_ranges;
+
+// #Medium #Array #String #Prefix_Sum #2023_08_19_Time_4_ms_(99.59%)_Space_85.6_MB_(78.46%)
+
+public class Solution {
+    private boolean validWord(String s) {
+        char cStart = s.charAt(0);
+        char cEnd = s.charAt(s.length() - 1);
+        boolean flag1 =
+                cStart == 'a' || cStart == 'e' || cStart == 'i' || cStart == 'o' || cStart == 'u';
+        boolean flag2 = cEnd == 'a' || cEnd == 'e' || cEnd == 'i' || cEnd == 'o' || cEnd == 'u';
+        return flag1 && flag2;
+    }
+
+    public int[] vowelStrings(String[] words, int[][] queries) {
+        int[] prefixArr = new int[words.length];
+        prefixArr[0] = validWord(words[0]) ? 1 : 0;
+        for (int i = 1; i < words.length; ++i) {
+            if (validWord(words[i])) {
+                prefixArr[i] = prefixArr[i - 1] + 1;
+            } else {
+                prefixArr[i] = prefixArr[i - 1];
+            }
+        }
+        int[] res = new int[queries.length];
+        for (int i = 0; i < queries.length; ++i) {
+            int upperBound = queries[i][1];
+            int lowerBound = queries[i][0];
+            int val =
+                    (lowerBound == 0)
+                            ? prefixArr[upperBound]
+                            : prefixArr[upperBound] - prefixArr[lowerBound - 1];
+            res[i] = val;
+        }
+        return res;
+    }
+}

src/main/java/g2501_2600/s2559_count_vowel_strings_in_ranges/readme.md

@@ -0,0 +1,44 @@
+2559\. Count Vowel Strings in Ranges
+
+Medium
+
+You are given a **0-indexed** array of strings `words` and a 2D array of integers `queries`.
+
+Each query <code>queries[i] = [l<sub>i</sub>, r<sub>i</sub>]</code> asks us to find the number of strings present in the range <code>l<sub>i</sub></code> to <code>r<sub>i</sub></code> (both **inclusive**) of `words` that start and end with a vowel.
+
+Return _an array_ `ans` _of size_ `queries.length`_, where_ `ans[i]` _is the answer to the_ `i`<sup>th</sup> _query_.
+
+**Note** that the vowel letters are `'a'`, `'e'`, `'i'`, `'o'`, and `'u'`.
+
+**Example 1:**
+
+**Input:** words = ["aba","bcb","ece","aa","e"], queries = [[0,2],[1,4],[1,1]]
+
+**Output:** [2,3,0]
+
+**Explanation:** The strings starting and ending with a vowel are "aba", "ece", "aa" and "e". 
+
+The answer to the query [0,2] is 2 (strings "aba" and "ece"). 
+
+to query [1,4] is 3 (strings "ece", "aa", "e"). 
+
+to query [1,1] is 0. 
+
+We return [2,3,0].
+
+**Example 2:**
+
+**Input:** words = ["a","e","i"], queries = [[0,2],[0,1],[2,2]]
+
+**Output:** [3,2,1]
+
+**Explanation:** Every string satisfies the conditions, so we return [3,2,1].
+
+**Constraints:**
+
+*   <code>1 <= words.length <= 10<sup>5</sup></code>
+*   `1 <= words[i].length <= 40`
+*   `words[i]` consists only of lowercase English letters.
+*   <code>sum(words[i].length) <= 3 * 10<sup>5</sup></code>
+*   <code>1 <= queries.length <= 10<sup>5</sup></code>
+*   <code>0 <= l<sub>i</sub> <= r<sub>i</sub> < words.length</code>