Added tasks 1958, 1959, 1960, 1961, 1962.

Author: ThanhNIT

src/main/java/g1901_2000/s1958_check_if_move_is_legal/Solution.java

@@ -0,0 +1,40 @@
+package g1901_2000.s1958_check_if_move_is_legal;
+
+// #Medium #Array #Matrix #Enumeration #2022_05_20_Time_0_ms_(100.00%)_Space_43.9_MB_(11.63%)
+
+public class Solution {
+
+    private static final int[][] DIRS =
+            new int[][] {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
+
+    public boolean checkMove(char[][] board, int rMove, int cMove, char color) {
+        char opposite = (color == 'W' ? 'B' : (color == 'B' ? 'W' : ' '));
+        if (opposite == ' ' || !find(board, rMove, cMove, '.')) {
+            return false;
+        }
+        for (int[] dir : DIRS) {
+            int rNext = rMove + dir[0];
+            int cNext = cMove + dir[1];
+            if (find(board, rNext, cNext, opposite)) {
+                rNext += dir[0];
+                cNext += dir[1];
+                while (find(board, rNext, cNext, opposite)) {
+                    rNext += dir[0];
+                    cNext += dir[1];
+                }
+                if (find(board, rNext, cNext, color)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean find(char[][] board, final int r, final int c, final char target) {
+        return (r >= 0
+                && r < board.length
+                && c >= 0
+                && c < board[r].length
+                && board[r][c] == target);
+    }
+}

src/main/java/g1901_2000/s1958_check_if_move_is_legal/readme.md

@@ -0,0 +1,40 @@
+1958\. Check if Move is Legal
+
+Medium
+
+You are given a **0-indexed** `8 x 8` grid `board`, where `board[r][c]` represents the cell `(r, c)` on a game board. On the board, free cells are represented by `'.'`, white cells are represented by `'W'`, and black cells are represented by `'B'`.
+
+Each move in this game consists of choosing a free cell and changing it to the color you are playing as (either white or black). However, a move is only **legal** if, after changing it, the cell becomes the **endpoint of a good line** (horizontal, vertical, or diagonal).
+
+A **good line** is a line of **three or more cells (including the endpoints)** where the endpoints of the line are **one color**, and the remaining cells in the middle are the **opposite color** (no cells in the line are free). You can find examples for good lines in the figure below:
+
+![](https://assets.leetcode.com/uploads/2021/07/22/goodlines5.png)
+
+Given two integers `rMove` and `cMove` and a character `color` representing the color you are playing as (white or black), return `true` _if changing cell_ `(rMove, cMove)` _to color_ `color` _is a **legal** move, or_ `false` _if it is not legal_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/07/10/grid11.png)
+
+**Input:** board = [[".",".",".","B",".",".",".","."],[".",".",".","W",".",".",".","."],[".",".",".","W",".",".",".","."],[".",".",".","W",".",".",".","."],["W","B","B",".","W","W","W","B"],[".",".",".","B",".",".",".","."],[".",".",".","B",".",".",".","."],[".",".",".","W",".",".",".","."]], rMove = 4, cMove = 3, color = "B"
+
+**Output:** true
+
+**Explanation:** '.', 'W', and 'B' are represented by the colors blue, white, and black respectively, and cell (rMove, cMove) is marked with an 'X'. The two good lines with the chosen cell as an endpoint are annotated above with the red rectangles.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/07/10/grid2.png)
+
+**Input:** board = [[".",".",".",".",".",".",".","."],[".","B",".",".","W",".",".","."],[".",".","W",".",".",".",".","."],[".",".",".","W","B",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".","B","W",".","."],[".",".",".",".",".",".","W","."],[".",".",".",".",".",".",".","B"]], rMove = 4, cMove = 4, color = "W"
+
+**Output:** false
+
+**Explanation:** While there are good lines with the chosen cell as a middle cell, there are no good lines with the chosen cell as an endpoint.
+
+**Constraints:**
+
+*   `board.length == board[r].length == 8`
+*   `0 <= rMove, cMove < 8`
+*   `board[rMove][cMove] == '.'`
+*   `color` is either `'B'` or `'W'`.

src/main/java/g1901_2000/s1959_minimum_total_space_wasted_with_k_resizing_operations/Solution.java

@@ -0,0 +1,47 @@
+package g1901_2000.s1959_minimum_total_space_wasted_with_k_resizing_operations;
+
+// #Medium #Array #Dynamic_Programming #2022_05_20_Time_42_ms_(95.45%)_Space_43_MB_(66.67%)
+
+public class Solution {
+    public int minSpaceWastedKResizing(int[] arr, int k) {
+        int n = arr.length;
+        k++;
+        int[][] dp = new int[n][k + 1];
+
+        for (int j = 1; j <= k; j++) {
+            for (int i = n - 1; i >= 0; i--) {
+                int ele = n - i;
+                if (j == ele) {
+                    dp[i][j] = 0;
+                    continue;
+                }
+
+                if (j == 1) {
+                    int sum = 0;
+                    int maxEle = -1;
+                    for (int l = i; l < n; l++) {
+                        maxEle = Math.max(maxEle, arr[l]);
+                        sum += arr[l];
+                    }
+
+                    dp[i][j] = (maxEle * (n - i)) - sum;
+                    continue;
+                }
+                int maxEle = -1;
+                int sum = 0;
+                int ans = Integer.MAX_VALUE;
+                for (int cut = i; cut <= n - j; cut++) {
+                    maxEle = Math.max(maxEle, arr[cut]);
+                    sum += arr[cut];
+                    int recAns = dp[cut + 1][j - 1];
+                    int myAns = (maxEle * (cut - i + 1)) - (sum);
+                    ans = Math.min(ans, recAns + myAns);
+                }
+
+                dp[i][j] = ans;
+            }
+        }
+
+        return dp[0][k];
+    }
+}

src/main/java/g1901_2000/s1959_minimum_total_space_wasted_with_k_resizing_operations/readme.md

@@ -0,0 +1,53 @@
+1959\. Minimum Total Space Wasted With K Resizing Operations
+
+Medium
+
+You are currently designing a dynamic array. You are given a **0-indexed** integer array `nums`, where `nums[i]` is the number of elements that will be in the array at time `i`. In addition, you are given an integer `k`, the **maximum** number of times you can **resize** the array (to **any** size).
+
+The size of the array at time `t`, <code>size<sub>t</sub></code>, must be at least `nums[t]` because there needs to be enough space in the array to hold all the elements. The **space wasted** at time `t` is defined as <code>size<sub>t</sub> - nums[t]</code>, and the **total** space wasted is the **sum** of the space wasted across every time `t` where `0 <= t < nums.length`.
+
+Return _the **minimum** **total space wasted** if you can resize the array at most_ `k` _times_.
+
+**Note:** The array can have **any size** at the start and does **not** count towards the number of resizing operations.
+
+**Example 1:**
+
+**Input:** nums = [10,20], k = 0
+
+**Output:** 10
+
+**Explanation:** size = [20,20]. 
+
+We can set the initial size to be 20. 
+
+The total wasted space is (20 - 10) + (20 - 20) = 10.
+
+**Example 2:**
+
+**Input:** nums = [10,20,30], k = 1
+
+**Output:** 10
+
+**Explanation:** size = [20,20,30]. 
+
+We can set the initial size to be 20 and resize to 30 at time 2. 
+
+The total wasted space is (20 - 10) + (20 - 20) + (30 - 30) = 10.
+
+**Example 3:**
+
+**Input:** nums = [10,20,15,30,20], k = 2
+
+**Output:** 15
+
+**Explanation:** size = [10,20,20,30,30]. 
+
+We can set the initial size to 10, resize to 20 at time 1, and resize to 30 at time 3. 
+
+The total wasted space is (10 - 10) + (20 - 20) + (20 - 15) + (30 - 30) + (30 - 20) = 15.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 200`
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>
+*   `0 <= k <= nums.length - 1`

src/main/java/g1901_2000/s1960_maximum_product_of_the_length_of_two_palindromic_substrings/Solution.java

@@ -0,0 +1,74 @@
+package g1901_2000.s1960_maximum_product_of_the_length_of_two_palindromic_substrings;
+
+// #Hard #String #Hash_Function #Rolling_Hash #2022_05_20_Time_32_ms_(75.00%)_Space_44.7_MB_(91.67%)
+
+public class Solution {
+
+    public long maxProduct(String s) {
+        int n = s.length();
+        if (n == 2) {
+            return 1;
+        }
+        int[] len = manaCherS(s);
+
+        long[] left = new long[n];
+
+        int max = 1;
+        left[0] = max;
+        for (int i = 1; i <= n - 1; i++) {
+            if (len[(i - max - 1 + i) / 2] > max) {
+                max += 2;
+            }
+            left[i] = max;
+        }
+        max = 1;
+        long[] right = new long[n];
+        right[n - 1] = max;
+
+        for (int i = n - 2; i >= 0; i--) {
+            if (len[(i + max + 1 + i) / 2] > max) {
+                max += 2;
+            }
+            right[i] = max;
+        }
+
+        long res = 1;
+
+        for (int i = 1; i < n; i++) {
+            res = Math.max(res, left[i - 1] * right[i]);
+        }
+        return res;
+    }
+
+    private int[] manaCherS(String s) {
+
+        int len = s.length();
+        int[] p = new int[len];
+        int c = 0;
+        int r = 0;
+
+        for (int i = 0; i < len; i++) {
+            int mirror = (2 * c) - i;
+            if (i < r) {
+                p[i] = Math.min(r - i, p[mirror]);
+            }
+
+            int a = i + (1 + p[i]);
+            int b = i - (1 + p[i]);
+            while (a < len && b >= 0 && s.charAt(a) == s.charAt(b)) {
+                p[i]++;
+                a++;
+                b--;
+            }
+
+            if (i + p[i] > r) {
+                c = i;
+                r = i + p[i];
+            }
+        }
+        for (int i = 0; i < len; i++) {
+            p[i] = 1 + 2 * p[i];
+        }
+        return p;
+    }
+}

src/main/java/g1901_2000/s1960_maximum_product_of_the_length_of_two_palindromic_substrings/readme.md

@@ -0,0 +1,32 @@
+1960\. Maximum Product of the Length of Two Palindromic Substrings
+
+Hard
+
+You are given a **0-indexed** string `s` and are tasked with finding two **non-intersecting palindromic** substrings of **odd** length such that the product of their lengths is maximized.
+
+More formally, you want to choose four integers `i`, `j`, `k`, `l` such that `0 <= i <= j < k <= l < s.length` and both the substrings `s[i...j]` and `s[k...l]` are palindromes and have odd lengths. `s[i...j]` denotes a substring from index `i` to index `j` **inclusive**.
+
+Return _the **maximum** possible product of the lengths of the two non-intersecting palindromic substrings._
+
+A **palindrome** is a string that is the same forward and backward. A **substring** is a contiguous sequence of characters in a string.
+
+**Example 1:**
+
+**Input:** s = "ababbb"
+
+**Output:** 9
+
+**Explanation:** Substrings "aba" and "bbb" are palindromes with odd length. product = 3 \* 3 = 9.
+
+**Example 2:**
+
+**Input:** s = "zaaaxbbby"
+
+**Output:** 9
+
+**Explanation:** Substrings "aaa" and "bbb" are palindromes with odd length. product = 3 \* 3 = 9.
+
+**Constraints:**
+
+*   <code>2 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of lowercase English letters.

src/main/java/g1901_2000/s1961_check_if_string_is_a_prefix_of_array/Solution.java

@@ -0,0 +1,16 @@
+package g1901_2000.s1961_check_if_string_is_a_prefix_of_array;
+
+// #Easy #Array #String #2022_05_20_Time_2_ms_(60.87%)_Space_43.5_MB_(27.83%)
+
+public class Solution {
+    public boolean isPrefixString(String s, String[] words) {
+        StringBuilder sb = new StringBuilder();
+        for (String word : words) {
+            sb.append(word);
+            if (sb.toString().equals(s)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/main/java/g1901_2000/s1961_check_if_string_is_a_prefix_of_array/readme.md

@@ -0,0 +1,32 @@
+1961\. Check If String Is a Prefix of Array
+
+Easy
+
+Given a string `s` and an array of strings `words`, determine whether `s` is a **prefix string** of `words`.
+
+A string `s` is a **prefix string** of `words` if `s` can be made by concatenating the first `k` strings in `words` for some **positive** `k` no larger than `words.length`.
+
+Return `true` _if_ `s` _is a **prefix string** of_ `words`_, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** s = "iloveleetcode", words = ["i","love","leetcode","apples"]
+
+**Output:** true
+
+**Explanation:** s can be made by concatenating "i", "love", and "leetcode" together.
+
+**Example 2:**
+
+**Input:** s = "iloveleetcode", words = ["apples","i","love","leetcode"]
+
+**Output:** false
+
+**Explanation:** It is impossible to make s using a prefix of arr.
+
+**Constraints:**
+
+*   `1 <= words.length <= 100`
+*   `1 <= words[i].length <= 20`
+*   `1 <= s.length <= 1000`
+*   `words[i]` and `s` consist of only lowercase English letters.

src/main/java/g1901_2000/s1962_remove_stones_to_minimize_the_total/Solution.java

@@ -0,0 +1,29 @@
+package g1901_2000.s1962_remove_stones_to_minimize_the_total;
+
+// #Medium #Array #Heap_Priority_Queue #2022_05_20_Time_761_ms_(48.67%)_Space_124.8_MB_(24.78%)
+
+import java.util.Collections;
+import java.util.PriorityQueue;
+
+public class Solution {
+    public int minStoneSum(int[] piles, int k) {
+        PriorityQueue<Integer> descendingQueue = new PriorityQueue<>(Collections.reverseOrder());
+        int sum = 0;
+        int newValue;
+        int currentValue;
+        int half;
+        for (int stones : piles) {
+            sum += stones;
+            descendingQueue.offer(stones);
+        }
+        while (k > 0) {
+            currentValue = descendingQueue.poll();
+            half = currentValue / 2;
+            newValue = currentValue - half;
+            descendingQueue.offer(newValue);
+            sum -= half;
+            k--;
+        }
+        return sum;
+    }
+}