Added tasks 2575-2579

Author: ThanhNIT

src/main/java/g2501_2600/s2575_find_the_divisibility_array_of_a_string/Solution.java

@@ -0,0 +1,19 @@
+package g2501_2600.s2575_find_the_divisibility_array_of_a_string;
+
+// #Medium #Array #String #Math #2023_08_22_Time_6_ms_(100.00%)_Space_56.4_MB_(49.79%)
+
+public class Solution {
+    public int[] divisibilityArray(String word, int m) {
+        int n = word.length();
+        long modulo = 0;
+        int[] result = new int[n];
+        for (int i = 0; i < n; i++) {
+            int numericValue = word.charAt(i) - '0';
+            modulo = (modulo * 10 + numericValue) % m;
+            if (modulo == 0) {
+                result[i] = 1;
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,35 @@
+2575\. Find the Divisibility Array of a String
+
+Medium
+
+You are given a **0-indexed** string `word` of length `n` consisting of digits, and a positive integer `m`.
+
+The **divisibility array** `div` of `word` is an integer array of length `n` such that:
+
+*   `div[i] = 1` if the **numeric value** of `word[0,...,i]` is divisible by `m`, or
+*   `div[i] = 0` otherwise.
+
+Return _the divisibility array of_ `word`.
+
+**Example 1:**
+
+**Input:** word = "998244353", m = 3
+
+**Output:** [1,1,0,0,0,1,1,0,0]
+
+**Explanation:** There are only 4 prefixes that are divisible by 3: "9", "99", "998244", and "9982443".
+
+**Example 2:**
+
+**Input:** word = "1010", m = 10
+
+**Output:** [0,1,0,1]
+
+**Explanation:** There are only 2 prefixes that are divisible by 10: "10", and "1010".
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `word.length == n`
+*   `word` consists of digits from `0` to `9`
+*   <code>1 <= m <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2576_find_the_maximum_number_of_marked_indices/Solution.java

@@ -0,0 +1,25 @@
+package g2501_2600.s2576_find_the_maximum_number_of_marked_indices;
+
+// #Medium #Array #Sorting #Greedy #Binary_Search #Two_Pointers
+// #2023_08_22_Time_27_ms_(95.36%)_Space_54.9_MB_(88.74%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int maxNumOfMarkedIndices(int[] nums) {
+        Arrays.sort(nums);
+        int i = 0;
+        int j = nums.length / 2;
+        long count = 0;
+        while (i < nums.length / 2 && j < nums.length) {
+            if (nums[i] * 2 <= nums[j]) {
+                i++;
+                j++;
+                count = count + 2;
+            } else {
+                j++;
+            }
+        }
+        return (int) count;
+    }
+}

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

@@ -0,0 +1,46 @@
+2576\. Find the Maximum Number of Marked Indices
+
+Medium
+
+You are given a **0-indexed** integer array `nums`.
+
+Initially, all of the indices are unmarked. You are allowed to make this operation any number of times:
+
+*   Pick two **different unmarked** indices `i` and `j` such that `2 * nums[i] <= nums[j]`, then mark `i` and `j`.
+
+Return _the maximum possible number of marked indices in `nums` using the above operation any number of times_.
+
+**Example 1:**
+
+**Input:** nums = [3,5,2,4]
+
+**Output:** 2
+
+**Explanation:** In the first operation: pick i = 2 and j = 1, the operation is allowed because 2 \* nums[2] <= nums[1]. Then mark index 2 and 1. It can be shown that there's no other valid operation so the answer is 2.
+
+**Example 2:**
+
+**Input:** nums = [9,2,5,4]
+
+**Output:** 4
+
+**Explanation:** In the first operation: pick i = 3 and j = 0, the operation is allowed because 2 \* nums[3] <= nums[0]. 
+
+Then mark index 3 and 0. 
+
+In the second operation: pick i = 1 and j = 2, the operation is allowed because 2 \* nums[1] <= nums[2]. Then mark index 1 and 2. 
+
+Since there is no other operation, the answer is 4.
+
+**Example 3:**
+
+**Input:** nums = [7,6,8]
+
+**Output:** 0
+
+**Explanation:** There is no valid operation to do, so the answer is 0.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2577_minimum_time_to_visit_a_cell_in_a_grid/Solution.java

@@ -0,0 +1,63 @@
+package g2501_2600.s2577_minimum_time_to_visit_a_cell_in_a_grid;
+
+// #Hard #Array #Breadth_First_Search #Matrix #Heap_Priority_Queue #Graph #Shortest_Path
+// #2023_08_22_Time_132_ms_(85.82%)_Space_56_MB_(57.46%)
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public int minimumTime(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        if (grid[0][1] > 1 && grid[1][0] > 1) {
+            return -1;
+        }
+        PriorityQueue<Node> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a.time));
+        pq.add(new Node(0, 0, 0));
+        int[] xDir = {0, 0, 1, -1};
+        int[] yDir = {1, -1, 0, 0};
+        int[][] vis = new int[m][n];
+        for (int[] temp : vis) {
+            Arrays.fill(temp, -1);
+        }
+        while (!pq.isEmpty()) {
+            Node curr = pq.remove();
+            if (curr.x == m - 1 && curr.y == n - 1) {
+                return curr.time;
+            }
+            vis[curr.x][curr.y] = 1;
+            int currTime = curr.time + 1;
+            for (int i = 0; i < 4; i++) {
+                int newX = curr.x + xDir[i];
+                int newY = curr.y + yDir[i];
+                if (newX >= 0 && newY >= 0 && newX < m && newY < n && vis[newX][newY] == -1) {
+                    vis[newX][newY] = 1;
+                    if (grid[newX][newY] <= currTime) {
+                        pq.add(new Node(newX, newY, currTime));
+                    } else {
+                        if ((grid[newX][newY] - curr.time) % 2 == 0) {
+                            pq.add(new Node(newX, newY, grid[newX][newY] + 1));
+                        } else {
+                            pq.add(new Node(newX, newY, grid[newX][newY]));
+                        }
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+
+    private static class Node {
+        int x;
+        int y;
+        int time;
+
+        Node(int xx, int yy, int tt) {
+            x = xx;
+            y = yy;
+            time = tt;
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+2577\. Minimum Time to Visit a Cell In a Grid
+
+Hard
+
+You are given a `m x n` matrix `grid` consisting of **non-negative** integers where `grid[row][col]` represents the **minimum** time required to be able to visit the cell `(row, col)`, which means you can visit the cell `(row, col)` only when the time you visit it is greater than or equal to `grid[row][col]`.
+
+You are standing in the **top-left** cell of the matrix in the <code>0<sup>th</sup></code> second, and you must move to **any** adjacent cell in the four directions: up, down, left, and right. Each move you make takes 1 second.
+
+Return _the **minimum** time required in which you can visit the bottom-right cell of the matrix_. If you cannot visit the bottom-right cell, then return `-1`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-8.png)
+
+**Input:** grid = [[0,1,3,2],[5,1,2,5],[4,3,8,6]]
+
+**Output:** 7
+
+**Explanation:** One of the paths that we can take is the following:
+- at t = 0, we are on the cell (0,0). 
+- at t = 1, we move to the cell (0,1). It is possible because grid[0][1] <= 1. 
+- at t = 2, we move to the cell (1,1). It is possible because grid[1][1] <= 2. 
+- at t = 3, we move to the cell (1,2). It is possible because grid[1][2] <= 3. 
+- at t = 4, we move to the cell (1,1). It is possible because grid[1][1] <= 4. 
+- at t = 5, we move to the cell (1,2). It is possible because grid[1][2] <= 5. 
+- at t = 6, we move to the cell (1,3). It is possible because grid[1][3] <= 6. 
+- at t = 7, we move to the cell (2,3). It is possible because grid[2][3] <= 7. 
+
+The final time is 7. It can be shown that it is the minimum time possible.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/02/14/yetgriddrawio-9.png)
+
+**Input:** grid = [[0,2,4],[3,2,1],[1,0,4]]
+
+**Output:** -1
+
+**Explanation:** There is no path from the top left to the bottom-right cell.
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `2 <= m, n <= 1000`
+*   <code>4 <= m * n <= 10<sup>5</sup></code>
+*   <code>0 <= grid[i][j] <= 10<sup>5</sup></code>
+*   `grid[0][0] == 0`

src/main/java/g2501_2600/s2578_split_with_minimum_sum/Solution.java

@@ -0,0 +1,30 @@
+package g2501_2600.s2578_split_with_minimum_sum;
+
+// #Easy #Math #Sorting #Greedy #2023_08_22_Time_0_ms_(100.00%)_Space_39.3_MB_(76.63%)
+
+public class Solution {
+    public int splitNum(int number) {
+        int num1 = 0;
+        int num2 = 0;
+        boolean addToOne = true;
+        for (int i = 0; i <= 9; i++) {
+            int tmpNumber = number;
+            while (tmpNumber > 0) {
+                int digit = tmpNumber % 10;
+                if (digit == i) {
+                    if (addToOne) {
+                        num1 *= 10;
+                        num1 += digit;
+                        addToOne = false;
+                    } else {
+                        num2 *= 10;
+                        num2 += digit;
+                        addToOne = true;
+                    }
+                }
+                tmpNumber /= 10;
+            }
+        }
+        return num1 + num2;
+    }
+}

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

@@ -0,0 +1,36 @@
+2578\. Split With Minimum Sum
+
+Easy
+
+Given a positive integer `num`, split it into two non-negative integers `num1` and `num2` such that:
+
+*   The concatenation of `num1` and `num2` is a permutation of `num`.
+    *   In other words, the sum of the number of occurrences of each digit in `num1` and `num2` is equal to the number of occurrences of that digit in `num`.
+*   `num1` and `num2` can contain leading zeros.
+
+Return _the **minimum** possible sum of_ `num1` _and_ `num2`.
+
+**Notes:**
+
+*   It is guaranteed that `num` does not contain any leading zeros.
+*   The order of occurrence of the digits in `num1` and `num2` may differ from the order of occurrence of `num`.
+
+**Example 1:**
+
+**Input:** num = 4325
+
+**Output:** 59
+
+**Explanation:** We can split 4325 so that `num1` is 24 and num2 `is` 35, giving a sum of 59. We can prove that 59 is indeed the minimal possible sum.
+
+**Example 2:**
+
+**Input:** num = 687
+
+**Output:** 75
+
+**Explanation:** We can split 687 so that `num1` is 68 and `num2` is 7, which would give an optimal sum of 75.
+
+**Constraints:**
+
+*   <code>10 <= num <= 10<sup>9</sup></code>

src/main/java/g2501_2600/s2579_count_total_number_of_colored_cells/Solution.java

@@ -0,0 +1,9 @@
+package g2501_2600.s2579_count_total_number_of_colored_cells;
+
+// #Medium #Math #2023_08_22_Time_0_ms_(100.00%)_Space_39.2_MB_(60.33%)
+
+public class Solution {
+    public long coloredCells(int n) {
+        return (long) Math.pow(n, 2) + (long) Math.pow(n - (double) 1, 2);
+    }
+}

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

@@ -0,0 +1,34 @@
+2579\. Count Total Number of Colored Cells
+
+Medium
+
+There exists an infinitely large two-dimensional grid of uncolored unit cells. You are given a positive integer `n`, indicating that you must do the following routine for `n` minutes:
+
+*   At the first minute, color **any** arbitrary unit cell blue.
+*   Every minute thereafter, color blue **every** uncolored cell that touches a blue cell.
+
+Below is a pictorial representation of the state of the grid after minutes 1, 2, and 3.
+
+![](https://assets.leetcode.com/uploads/2023/01/10/example-copy-2.png)
+
+Return _the number of **colored cells** at the end of_ `n` _minutes_.
+
+**Example 1:**
+
+**Input:** n = 1
+
+**Output:** 1
+
+**Explanation:** After 1 minute, there is only 1 blue cell, so we return 1.
+
+**Example 2:**
+
+**Input:** n = 2
+
+**Output:** 5
+
+**Explanation:** After 2 minutes, there are 4 colored cells on the boundary and 1 in the center, so we return 5.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>