Added tasks 2017, 2018, 2019, 2022, 2023.

Author: ThanhNIT

src/main/java/g2001_2100/s2017_grid_game/Solution.java

@@ -0,0 +1,20 @@
+package g2001_2100.s2017_grid_game;
+
+// #Medium #Array #Matrix #Prefix_Sum #2022_05_24_Time_10_ms_(41.46%)_Space_95.2_MB_(32.32%)
+
+public class Solution {
+    public long gridGame(int[][] grid) {
+        int n = grid[0].length;
+        long[] cum0 = new long[n + 1];
+        long[] cum1 = new long[n + 1];
+        for (int i = 0; i < n; i++) {
+            cum0[i + 1] = cum0[i] + grid[0][i];
+            cum1[i + 1] = cum1[i] + grid[1][i];
+        }
+        long ans = Long.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            ans = Math.min(ans, Math.max(cum0[n] - cum0[i + 1], cum1[i]));
+        }
+        return ans;
+    }
+}

src/main/java/g2001_2100/s2017_grid_game/readme.md

@@ -0,0 +1,60 @@
+2017\. Grid Game
+
+Medium
+
+You are given a **0-indexed** 2D array `grid` of size `2 x n`, where `grid[r][c]` represents the number of points at position `(r, c)` on the matrix. Two robots are playing a game on this matrix.
+
+Both robots initially start at `(0, 0)` and want to reach `(1, n-1)`. Each robot may only move to the **right** (`(r, c)` to `(r, c + 1)`) or **down** (`(r, c)` to `(r + 1, c)`).
+
+At the start of the game, the **first** robot moves from `(0, 0)` to `(1, n-1)`, collecting all the points from the cells on its path. For all cells `(r, c)` traversed on the path, `grid[r][c]` is set to `0`. Then, the **second** robot moves from `(0, 0)` to `(1, n-1)`, collecting the points on its path. Note that their paths may intersect with one another.
+
+The **first** robot wants to **minimize** the number of points collected by the **second** robot. In contrast, the **second** robot wants to **maximize** the number of points it collects. If both robots play **optimally**, return _the **number of points** collected by the **second** robot._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/09/08/a1.png)
+
+**Input:** grid = [[2,5,4],[1,5,1]]
+
+**Output:** 4
+
+**Explanation:** The optimal path taken by the first robot is shown in red, and the optimal path taken by the second robot is shown in blue. 
+
+The cells visited by the first robot are set to 0. 
+
+The second robot will collect 0 + 0 + 4 + 0 = 4 points.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/09/08/a2.png)
+
+**Input:** grid = [[3,3,1],[8,5,2]]
+
+**Output:** 4
+
+**Explanation:** The optimal path taken by the first robot is shown in red, and the optimal path taken by the second robot is shown in blue.
+
+The cells visited by the first robot are set to 0.
+
+The second robot will collect 0 + 3 + 1 + 0 = 4 points.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/09/08/a3.png)
+
+**Input:** grid = [[1,3,1,15],[1,3,3,1]]
+
+**Output:** 7
+
+**Explanation:** The optimal path taken by the first robot is shown in red, and the optimal path taken by the second robot is shown in blue. 
+
+The cells visited by the first robot are set to 0. 
+
+The second robot will collect 0 + 1 + 3 + 3 + 0 = 7 points.
+
+**Constraints:**
+
+*   `grid.length == 2`
+*   `n == grid[r].length`
+*   <code>1 <= n <= 5 * 10<sup>4</sup></code>
+*   <code>1 <= grid[r][c] <= 10<sup>5</sup></code>

src/main/java/g2001_2100/s2018_check_if_word_can_be_placed_in_crossword/Solution.java

@@ -0,0 +1,88 @@
+package g2001_2100.s2018_check_if_word_can_be_placed_in_crossword;
+
+// #Medium #Array #Matrix #Enumeration #2022_05_24_Time_11_ms_(52.76%)_Space_106.7_MB_(34.26%)
+
+public class Solution {
+    public boolean placeWordInCrossword(char[][] board, String word) {
+        int m = board.length;
+        int n = board[0].length;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if ((board[i][j] == ' ' || board[i][j] == word.charAt(0))
+                        && (canPlaceTopDown(word, board, i, j)
+                                || canPlaceLeftRight(word, board, i, j)
+                                || canPlaceBottomUp(word, board, i, j)
+                                || canPlaceRightLeft(word, board, i, j))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean canPlaceRightLeft(String word, char[][] board, int row, int col) {
+        if (col + 1 < board[0].length
+                && (Character.isLowerCase(board[row][col + 1]) || board[row][col + 1] == ' ')) {
+            return false;
+        }
+        int k = 0;
+        int j = col;
+        for (; j >= 0 && k < word.length(); j--) {
+            if (board[row][j] != word.charAt(k) && board[row][j] != ' ') {
+                return false;
+            } else {
+                k++;
+            }
+        }
+        return k == word.length() && (j < 0 || board[row][j] == '#');
+    }
+
+    private boolean canPlaceBottomUp(String word, char[][] board, int row, int col) {
+        if (row + 1 < board.length
+                && (Character.isLowerCase(board[row + 1][col]) || board[row + 1][col] == ' ')) {
+            return false;
+        }
+        int k = 0;
+        int i = row;
+        for (; i >= 0 && k < word.length(); i--) {
+            if (board[i][col] != word.charAt(k) && board[i][col] != ' ') {
+                return false;
+            } else {
+                k++;
+            }
+        }
+        return k == word.length() && (i < 0 || board[i][col] == '#');
+    }
+
+    private boolean canPlaceLeftRight(String word, char[][] board, int row, int col) {
+        if (col > 0 && (Character.isLowerCase(board[row][col - 1]) || board[row][col - 1] == ' ')) {
+            return false;
+        }
+        int k = 0;
+        int j = col;
+        for (; j < board[0].length && k < word.length(); j++) {
+            if (board[row][j] != word.charAt(k) && board[row][j] != ' ') {
+                return false;
+            } else {
+                k++;
+            }
+        }
+        return k == word.length() && (j == board[0].length || board[row][j] == '#');
+    }
+
+    private boolean canPlaceTopDown(String word, char[][] board, int row, int col) {
+        if (row > 0 && (Character.isLowerCase(board[row - 1][col]) || board[row - 1][col] == ' ')) {
+            return false;
+        }
+        int k = 0;
+        int i = row;
+        for (; i < board.length && k < word.length(); i++) {
+            if (board[i][col] != word.charAt(k) && board[i][col] != ' ') {
+                return false;
+            } else {
+                k++;
+            }
+        }
+        return k == word.length() && (i == board.length || board[i][col] == '#');
+    }
+}

src/main/java/g2001_2100/s2018_check_if_word_can_be_placed_in_crossword/readme.md

@@ -0,0 +1,53 @@
+2018\. Check if Word Can Be Placed In Crossword
+
+Medium
+
+You are given an `m x n` matrix `board`, representing the **current** state of a crossword puzzle. The crossword contains lowercase English letters (from solved words), `' '` to represent any **empty** cells, and `'#'` to represent any **blocked** cells.
+
+A word can be placed **horizontally** (left to right **or** right to left) or **vertically** (top to bottom **or** bottom to top) in the board if:
+
+*   It does not occupy a cell containing the character `'#'`.
+*   The cell each letter is placed in must either be `' '` (empty) or **match** the letter already on the `board`.
+*   There must not be any empty cells `' '` or other lowercase letters **directly left or right** of the word if the word was placed **horizontally**.
+*   There must not be any empty cells `' '` or other lowercase letters **directly above or below** the word if the word was placed **vertically**.
+
+Given a string `word`, return `true` _if_ `word` _can be placed in_ `board`_, or_ `false` _**otherwise**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/10/04/crossword-ex1-1.png)
+
+**Input:** board = [["#", " ", "#"], [" ", " ", "#"], ["#", "c", " "]], word = "abc"
+
+**Output:** true
+
+**Explanation:** The word "abc" can be placed as shown above (top to bottom).
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/10/04/crossword-ex2-1.png)
+
+**Input:** board = [[" ", "#", "a"], [" ", "#", "c"], [" ", "#", "a"]], word = "ac"
+
+**Output:** false
+
+**Explanation:** It is impossible to place the word because there will always be a space/letter above or below it.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/10/04/crossword-ex3-1.png)
+
+**Input:** board = [["#", " ", "#"], [" ", " ", "#"], ["#", " ", "c"]], word = "ca"
+
+**Output:** true
+
+**Explanation:** The word "ca" can be placed as shown above (right to left).
+
+**Constraints:**
+
+*   `m == board.length`
+*   `n == board[i].length`
+*   <code>1 <= m * n <= 2 * 10<sup>5</sup></code>
+*   `board[i][j]` will be `' '`, `'#'`, or a lowercase English letter.
+*   `1 <= word.length <= max(m, n)`
+*   `word` will contain only lowercase English letters.

src/main/java/g2001_2100/s2019_the_score_of_students_solving_math_expression/Solution.java

@@ -0,0 +1,81 @@
+package g2001_2100.s2019_the_score_of_students_solving_math_expression;
+
+// #Hard #Array #String #Dynamic_Programming #Math #Stack #Memoization
+// #2022_05_24_Time_435_ms_(89.93%)_Space_47_MB_(87.77%)
+
+import java.util.ArrayDeque;
+import java.util.HashSet;
+
+public class Solution {
+    private HashSet<?>[][] dp;
+
+    public int scoreOfStudents(String s, int[] answers) {
+        ArrayDeque<Integer> st = new ArrayDeque<>();
+        int n = s.length();
+        int i = 0;
+        dp = new HashSet<?>[n][n];
+        while (i < n) {
+            if (s.charAt(i) - '0' >= 0 && s.charAt(i) - '9' <= 0) {
+                st.push(s.charAt(i) - '0');
+                i++;
+            } else if (s.charAt(i) == '*') {
+                int cur = st.pop() * (s.charAt(i + 1) - '0');
+                i += 2;
+                st.push(cur);
+            } else {
+                i++;
+            }
+        }
+        int res = 0;
+        int ret = 0;
+        while (!st.isEmpty()) {
+            res += st.pop();
+        }
+        HashSet<Integer> wrong = opts(0, n - 1, s);
+        for (int ans : answers) {
+            if (ans == res) {
+                ret += 5;
+            } else if (wrong.contains(ans)) {
+                ret += 2;
+            }
+        }
+        return ret;
+    }
+
+    private HashSet<Integer> opts(int i, int j, String s) {
+        if (dp[i][j] != null) {
+            return (HashSet<Integer>) dp[i][j];
+        }
+        if (i == j) {
+            HashSet<Integer> res = new HashSet<>();
+            res.add(s.charAt(i) - '0');
+            dp[i][j] = res;
+            return res;
+        }
+        HashSet<Integer> res = new HashSet<>();
+        for (int x = i + 1; x < j; x += 2) {
+            char op = s.charAt(x);
+            HashSet<Integer> left = opts(i, x - 1, s);
+            HashSet<Integer> right = opts(x + 1, j, s);
+            if (op == '*') {
+                for (int l : left) {
+                    for (int r : right) {
+                        if (l * r <= 1000) {
+                            res.add(l * r);
+                        }
+                    }
+                }
+            } else {
+                for (int l : left) {
+                    for (int r : right) {
+                        if (l + r <= 1000) {
+                            res.add(l + r);
+                        }
+                    }
+                }
+            }
+        }
+        dp[i][j] = res;
+        return res;
+    }
+}

src/main/java/g2001_2100/s2019_the_score_of_students_solving_math_expression/readme.md

@@ -0,0 +1,67 @@
+2019\. The Score of Students Solving Math Expression
+
+Hard
+
+You are given a string `s` that contains digits `0-9`, addition symbols `'+'`, and multiplication symbols `'*'` **only**, representing a **valid** math expression of **single digit numbers** (e.g., `3+5*2`). This expression was given to `n` elementary school students. The students were instructed to get the answer of the expression by following this **order of operations**:
+
+1.  Compute **multiplication**, reading from **left to right**; Then,
+2.  Compute **addition**, reading from **left to right**.
+
+You are given an integer array `answers` of length `n`, which are the submitted answers of the students in no particular order. You are asked to grade the `answers`, by following these **rules**:
+
+*   If an answer **equals** the correct answer of the expression, this student will be rewarded `5` points;
+*   Otherwise, if the answer **could be interpreted** as if the student applied the operators **in the wrong order** but had **correct arithmetic**, this student will be rewarded `2` points;
+*   Otherwise, this student will be rewarded `0` points.
+
+Return _the sum of the points of the students_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/09/17/student_solving_math.png)
+
+**Input:** s = "7+3\*1\*2", answers = [20,13,42]
+
+**Output:** 7
+
+**Explanation:** As illustrated above, the correct answer of the expression is 13, therefore one student is rewarded 5 points: [20,**13**,42] 
+
+A student might have applied the operators in this wrong order: ((7+3)\*1)\*2 = 20. Therefore one student is rewarded 2 points: [**20**,13,42] 
+
+The points for the students are: [2,5,0]. The sum of the points is 2+5+0=7.
+
+**Example 2:**
+
+**Input:** s = "3+5\*2", answers = [13,0,10,13,13,16,16]
+
+**Output:** 19
+
+**Explanation:** The correct answer of the expression is 13, therefore three students are rewarded 5 points each: [**13**,0,10,**13**,**13**,16,16]
+
+A student might have applied the operators in this wrong order: ((3+5)\*2 = 16. Therefore two students are rewarded 2 points: [13,0,10,13,13,**16**,**16**] 
+
+The points for the students are: [5,0,0,5,5,2,2]. The sum of the points is 5+0+0+5+5+2+2=19.
+
+**Example 3:**
+
+**Input:** s = "6+0\*1", answers = [12,9,6,4,8,6]
+
+**Output:** 10
+
+**Explanation:** The correct answer of the expression is 6. 
+
+If a student had incorrectly done (6+0)\*1, the answer would also be 6. 
+
+By the rules of grading, the students will still be rewarded 5 points (as they got the correct answer), not 2 points. 
+
+The points for the students are: [0,0,5,0,0,5]. The sum of the points is 10.
+
+**Constraints:**
+
+*   `3 <= s.length <= 31`
+*   `s` represents a valid expression that contains only digits `0-9`, `'+'`, and `'*'` only.
+*   All the integer operands in the expression are in the **inclusive** range `[0, 9]`.
+*   `1 <=` The count of all operators (`'+'` and `'*'`) in the math expression `<= 15`
+*   Test data are generated such that the correct answer of the expression is in the range of `[0, 1000]`.
+*   `n == answers.length`
+*   <code>1 <= n <= 10<sup>4</sup></code>
+*   `0 <= answers[i] <= 1000`

src/main/java/g2001_2100/s2022_convert_1d_array_into_2d_array/Solution.java

@@ -0,0 +1,20 @@
+package g2001_2100.s2022_convert_1d_array_into_2d_array;
+
+// #Easy #Array #Matrix #Simulation #2022_05_25_Time_8_ms_(40.41%)_Space_119.4_MB_(53.92%)
+
+public class Solution {
+    public int[][] construct2DArray(int[] original, int m, int n) {
+        int size = original.length;
+        if (m * n != size) {
+            return new int[][] {};
+        }
+        int[][] ans = new int[m][n];
+        int k = 0;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                ans[i][j] = original[k++];
+            }
+        }
+        return ans;
+    }
+}