Added tasks 2809-2824

Author: javadev

Diff for: src/main/java/g2801_2900/s2809_minimum_time_to_make_array_sum_at_most_x/Solution.java

@@ -0,0 +1,38 @@
+package g2801_2900.s2809_minimum_time_to_make_array_sum_at_most_x;
+
+// #Hard #Array #Dynamic_Programming #Sorting #2023_11_20_Time_14_ms_(100.00%)_Space_44_MB_(47.62%)
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    public int minimumTime(List<Integer> nums1, List<Integer> nums2, int x) {
+        int n = nums1.size();
+        int[][] nums = new int[n][2];
+        for (int i = 0; i < n; i++) {
+            nums[i] = new int[] {nums1.get(i), nums2.get(i)};
+        }
+        Arrays.sort(nums, (a, b) -> a[1] - b[1]);
+        int[] dp = new int[n + 1];
+        long sum1 = 0;
+        long sum2 = 0;
+        for (int i = 0; i < n; i++) {
+            sum1 += nums[i][0];
+            sum2 += nums[i][1];
+        }
+        if (sum1 <= x) {
+            return 0;
+        }
+        for (int j = 0; j < n; j++) {
+            for (int i = j + 1; i > 0; i--) {
+                dp[i] = Math.max(dp[i], nums[j][0] + (nums[j][1] * i) + dp[i - 1]);
+            }
+        }
+        for (int i = 1; i <= n; i++) {
+            if (sum1 + sum2 * i - dp[i] <= x) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}

Diff for: src/main/java/g2801_2900/s2809_minimum_time_to_make_array_sum_at_most_x/readme.md

@@ -0,0 +1,40 @@
+2809\. Minimum Time to Make Array Sum At Most x
+
+Hard
+
+You are given two **0-indexed** integer arrays `nums1` and `nums2` of equal length. Every second, for all indices `0 <= i < nums1.length`, value of `nums1[i]` is incremented by `nums2[i]`. **After** this is done, you can do the following operation:
+
+*   Choose an index `0 <= i < nums1.length` and make `nums1[i] = 0`.
+
+You are also given an integer `x`.
+
+Return _the **minimum** time in which you can make the sum of all elements of_ `nums1` _to be **less than or equal** to_ `x`, _or_ `-1` _if this is not possible._
+
+**Example 1:**
+
+**Input:** nums1 = [1,2,3], nums2 = [1,2,3], x = 4
+
+**Output:** 3
+
+**Explanation:**
+
+    For the 1st second, we apply the operation on i = 0. Therefore nums1 = [0,2+2,3+3] = [0,4,6].
+    For the 2nd second, we apply the operation on i = 1. Therefore nums1 = [0+1,0,6+3] = [1,0,9].
+    For the 3rd second, we apply the operation on i = 2. Therefore nums1 = [1+1,0+2,0] = [2,2,0].
+    Now sum of nums1 = 4. It can be shown that these operations are optimal, so we return 3. 
+
+**Example 2:**
+
+**Input:** nums1 = [1,2,3], nums2 = [3,3,3], x = 4
+
+**Output:** -1
+
+**Explanation:** It can be shown that the sum of nums1 will always be greater than x, no matter which operations are performed. 
+
+**Constraints:**
+
+*   <code>1 <= nums1.length <= 10<sup>3</sup></code>
+*   <code>1 <= nums1[i] <= 10<sup>3</sup></code>
+*   <code>0 <= nums2[i] <= 10<sup>3</sup></code>
+*   `nums1.length == nums2.length`
+*   <code>0 <= x <= 10<sup>6</sup></code>

Diff for: src/main/java/g2801_2900/s2810_faulty_keyboard/Solution.java

@@ -0,0 +1,17 @@
+package g2801_2900.s2810_faulty_keyboard;
+
+// #Easy #String #Simulation #2023_11_20_Time_3_ms_(96.04%)_Space_44.2_MB_(14.74%)
+
+public class Solution {
+    public String finalString(String s) {
+        StringBuilder stringBuilder = new StringBuilder();
+        for (char ch : s.toCharArray()) {
+            if (ch == 'i') {
+                stringBuilder.reverse();
+                continue;
+            }
+            stringBuilder.append(ch);
+        }
+        return stringBuilder.toString();
+    }
+}

Diff for: src/main/java/g2801_2900/s2810_faulty_keyboard/readme.md

@@ -0,0 +1,59 @@
+2810\. Faulty Keyboard
+
+Easy
+
+Your laptop keyboard is faulty, and whenever you type a character `'i'` on it, it reverses the string that you have written. Typing other characters works as expected.
+
+You are given a **0-indexed** string `s`, and you type each character of `s` using your faulty keyboard.
+
+Return _the final string that will be present on your laptop screen._
+
+**Example 1:**
+
+**Input:** s = "string"
+
+**Output:** "rtsng"
+
+**Explanation:**
+
+After typing first character, the text on the screen is "s".
+
+After the second character, the text is "st".
+
+After the third character, the text is "str".
+
+Since the fourth character is an 'i', the text gets reversed and becomes "rts".
+
+After the fifth character, the text is "rtsn".
+
+After the sixth character, the text is "rtsng".
+
+Therefore, we return "rtsng". 
+
+**Example 2:**
+
+**Input:** s = "poiinter"
+
+**Output:** "ponter"
+
+**Explanation:**
+
+After the first character, the text on the screen is "p".
+
+After the second character, the text is "po".
+
+Since the third character you type is an 'i', the text gets reversed and becomes "op".
+
+Since the fourth character you type is an 'i', the text gets reversed and becomes "po".
+
+After the fifth character, the text is "pon". After the sixth character, the text is "pont".
+
+After the seventh character, the text is "ponte". After the eighth character, the text is "ponter".
+
+Therefore, we return "ponter".
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s` consists of lowercase English letters.
+*   `s[0] != 'i'`

Diff for: src/main/java/g2801_2900/s2811_check_if_it_is_possible_to_split_array/Solution.java

@@ -0,0 +1,20 @@
+package g2801_2900.s2811_check_if_it_is_possible_to_split_array;
+
+// #Medium #Array #Dynamic_Programming #Greedy #2023_11_20_Time_1_ms_(98.31%)_Space_43_MB_(50.00%)
+
+import java.util.List;
+
+public class Solution {
+    public boolean canSplitArray(List<Integer> nums, int m) {
+        if (nums.size() < 3 && !nums.isEmpty()) {
+            return true;
+        }
+        boolean ans = false;
+        for (int i = 0; i < nums.size() - 1; i++) {
+            if (nums.get(i) + nums.get(i + 1) >= m) {
+                ans = true;
+            }
+        }
+        return ans;
+    }
+}

Diff for: src/main/java/g2801_2900/s2811_check_if_it_is_possible_to_split_array/readme.md

@@ -0,0 +1,44 @@
+2811\. Check if it is Possible to Split Array
+
+Medium
+
+You are given an array `nums` of length `n` and an integer `m`. You need to determine if it is possible to split the array into `n` **non-empty** arrays by performing a series of steps.
+
+In each step, you can select an existing array (which may be the result of previous steps) with a length of **at least two** and split it into **two** subarrays, if, **for each** resulting subarray, **at least** one of the following holds:
+
+*   The length of the subarray is one, or
+*   The sum of elements of the subarray is **greater than or equal** to `m`.
+
+Return `true` _if you can split the given array into_ `n` _arrays, otherwise return_ `false`.
+
+**Note:** A subarray is _a contiguous non-empty sequence of elements within an array_.
+
+**Example 1:**
+
+**Input:** nums = [2, 2, 1], m = 4
+
+**Output:** true
+
+**Explanation:** We can split the array into [2, 2] and [1] in the first step. Then, in the second step, we can split [2, 2] into [2] and [2]. As a result, the answer is true.
+
+**Example 2:**
+
+**Input:** nums = [2, 1, 3], m = 5
+
+**Output:** false
+
+**Explanation:** We can try splitting the array in two different ways: the first way is to have [2, 1] and [3], and the second way is to have [2] and [1, 3]. However, both of these ways are not valid. So, the answer is false.
+
+**Example 3:**
+
+**Input:** nums = [2, 3, 3, 2, 3], m = 6
+
+**Output:** true
+
+**Explanation:** We can split the array into [2, 3, 3, 2] and [3] in the first step. Then, in the second step, we can split [2, 3, 3, 2] into [2, 3, 3] and [2]. Then, in the third step, we can split [2, 3, 3] into [2] and [3, 3]. And in the last step we can split [3, 3] into [3] and [3]. As a result, the answer is true. 
+
+**Constraints:**
+
+*   `1 <= n == nums.length <= 100`
+*   `1 <= nums[i] <= 100`
+*   `1 <= m <= 200`

Diff for: src/main/java/g2801_2900/s2812_find_the_safest_path_in_a_grid/Solution.java

@@ -0,0 +1,102 @@
+package g2801_2900.s2812_find_the_safest_path_in_a_grid;
+
+// #Medium #Array #Binary_Search #Matrix #Union_Find #Breadth_First_Search
+// #2023_11_20_Time_57_ms_(100.00%)_Space_65.3_MB_(77.00%)
+
+import java.util.Arrays;
+import java.util.List;
+
+@SuppressWarnings("java:S6541")
+public class Solution {
+    private static final int[][] MOVES = new int[][] {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
+
+    public int maximumSafenessFactor(List<List<Integer>> grid) {
+        final int yLen = grid.size();
+        final int xLen = grid.get(0).size();
+        if (grid.get(0).get(0) == 1 || grid.get(yLen - 1).get(xLen - 1) == 1) {
+            return 0;
+        }
+        int[][] secure = new int[yLen][xLen];
+        int[] deque = new int[yLen * xLen];
+        int[] nDeque = new int[yLen * xLen];
+        int[] tmpDeque;
+        int[] queue = new int[yLen * xLen];
+        int[] root = new int[yLen * xLen];
+        int head = -1;
+        int tail = -1;
+        int qIdx = -1;
+        int end = yLen * xLen - 1;
+        int curY;
+        int curX;
+        int nextY;
+        int nextX;
+        int curID;
+        int nextID;
+        for (int y = 0; y < yLen; y++) {
+            Arrays.fill(secure[y], -1);
+            for (int x = 0; x < xLen; x++) {
+                if (grid.get(y).get(x) == 1) {
+                    secure[y][x] = 0;
+                    curID = y * xLen + x;
+                    root[curID] = queue[++qIdx] = nDeque[++tail] = curID;
+                }
+            }
+        }
+        int start = 0;
+        int stop = qIdx;
+        for (int t = 1; tail > -1; t++) {
+            tmpDeque = deque;
+            deque = nDeque;
+            nDeque = tmpDeque;
+            head = tail;
+            tail = -1;
+            start = qIdx;
+            for (; head >= 0; head--) {
+                curY = deque[head] / xLen;
+                curX = deque[head] % xLen;
+                for (int[] move : MOVES) {
+                    nextY = curY + move[0];
+                    nextX = curX + move[1];
+                    if (nextY >= 0
+                            && nextY < yLen
+                            && nextX >= 0
+                            && nextX < xLen
+                            && secure[nextY][nextX] < 0) {
+                        secure[nextY][nextX] = t;
+                        nextID = nextY * xLen + nextX;
+                        root[nextID] = queue[++qIdx] = nDeque[++tail] = nextID;
+                    }
+                }
+            }
+        }
+        for (qIdx = start; qIdx > stop; qIdx--) {
+            curY = queue[qIdx] / xLen;
+            curX = queue[qIdx] % xLen;
+            curID = curY * xLen + curX;
+            for (int[] move : MOVES) {
+                nextY = curY + move[0];
+                nextX = curX + move[1];
+                if (nextY >= 0
+                        && nextY < yLen
+                        && nextX >= 0
+                        && nextX < xLen
+                        && secure[nextY][nextX] >= secure[curY][curX]) {
+                    nextID = nextY * xLen + nextX;
+                    root[find(root, curID)] = find(root, nextID);
+                }
+            }
+            if (find(root, 0) == find(root, end)) {
+                return secure[curY][curX];
+            }
+        }
+        return 0;
+    }
+
+    private int find(int[] root, int idx) {
+        if (idx == root[idx]) {
+            return idx;
+        }
+        root[idx] = find(root, root[idx]);
+        return root[idx];
+    }
+}