Added tasks 1031, 1032, 1033, 1034, 1035.

Author: ThanhNIT

src/main/java/g1001_1100/s1031_maximum_sum_of_two_non_overlapping_subarrays/Solution.java

@@ -0,0 +1,59 @@
+package g1001_1100.s1031_maximum_sum_of_two_non_overlapping_subarrays;
+
+// #Medium #Array #Dynamic_Programming #Sliding_Window
+// #2022_02_27_Time_3_ms_(46.04%)_Space_43.2_MB_(12.23%)
+
+public class Solution {
+    public int maxSumTwoNoOverlap(int[] nums, int f, int s) {
+        int sum = 0;
+        int n = nums.length;
+        int[] pref = new int[n];
+        int[] suff = new int[n];
+        for (int i = 0; i < n; i++) {
+            sum += nums[i];
+            if (i < f - 1) {
+                continue;
+            }
+
+            pref[i] = Math.max(i > 0 ? pref[i - 1] : 0, sum);
+
+            sum -= nums[i + 1 - f];
+        }
+
+        sum = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            sum += nums[i];
+            if (i > n - f) {
+                continue;
+            }
+
+            suff[i] = Math.max(i < n - 1 ? suff[i + 1] : 0, sum);
+
+            sum -= nums[i + f - 1];
+        }
+
+        sum = 0;
+
+        for (int i = 0; i < s - 1; i++) {
+            sum += nums[i];
+        }
+
+        int ans = Integer.MIN_VALUE;
+        for (int i = s - 1; i < n; i++) {
+
+            sum += nums[i];
+
+            if (i >= s) {
+                ans = Math.max(ans, pref[i - s] + sum);
+            }
+
+            if (i < n - 1) {
+                ans = Math.max(ans, suff[i + 1] + sum);
+            }
+
+            sum -= nums[i + 1 - s];
+        }
+
+        return ans;
+    }
+}

src/main/java/g1001_1100/s1031_maximum_sum_of_two_non_overlapping_subarrays/readme.md

@@ -0,0 +1,40 @@
+1031\. Maximum Sum of Two Non-Overlapping Subarrays
+
+Medium
+
+Given an integer array `nums` and two integers `firstLen` and `secondLen`, return _the maximum sum of elements in two non-overlapping **subarrays** with lengths_ `firstLen` _and_ `secondLen`.
+
+The array with length `firstLen` could occur before or after the array with length `secondLen`, but they have to be non-overlapping.
+
+A **subarray** is a **contiguous** part of an array.
+
+**Example 1:**
+
+**Input:** nums = [0,6,5,2,2,5,1,9,4], firstLen = 1, secondLen = 2
+
+**Output:** 20
+
+**Explanation:** One choice of subarrays is [9] with length 1, and [6,5] with length 2.
+
+**Example 2:**
+
+**Input:** nums = [3,8,1,3,2,1,8,9,0], firstLen = 3, secondLen = 2
+
+**Output:** 29
+
+**Explanation:** One choice of subarrays is [3,8,1] with length 3, and [8,9] with length 2.
+
+**Example 3:**
+
+**Input:** nums = [2,1,5,6,0,9,5,0,3,8], firstLen = 4, secondLen = 3
+
+**Output:** 31
+
+**Explanation:** One choice of subarrays is [5,6,0,9] with length 4, and [3,8] with length 3.
+
+**Constraints:**
+
+*   `1 <= firstLen, secondLen <= 1000`
+*   `2 <= firstLen + secondLen <= 1000`
+*   `firstLen + secondLen <= nums.length <= 1000`
+*   `0 <= nums[i] <= 1000`

src/main/java/g1001_1100/s1032_stream_of_characters/StreamChecker.java

@@ -0,0 +1,54 @@
+package g1001_1100.s1032_stream_of_characters;
+
+// #Hard #Array #String #Design #Trie #Data_Stream
+// #2022_02_27_Time_137_ms_(81.54%)_Space_148.2_MB_(53.37%)
+
+public class StreamChecker {
+    static class Node {
+        Node[] child;
+        boolean isEnd;
+
+        Node() {
+            child = new Node[26];
+        }
+    }
+
+    private final StringBuilder sb;
+    private final Node root;
+
+    public void insert(String s) {
+        Node curr = root;
+        for (int i = s.length() - 1; i >= 0; i--) {
+            char c = s.charAt(i);
+            if (curr.child[c - 'a'] == null) {
+                curr.child[c - 'a'] = new Node();
+            }
+            curr = curr.child[c - 'a'];
+        }
+        curr.isEnd = true;
+    }
+
+    public StreamChecker(String[] words) {
+        root = new Node();
+        sb = new StringBuilder();
+        for (String s : words) {
+            insert(s);
+        }
+    }
+
+    public boolean query(char letter) {
+        sb.append(letter);
+        Node curr = root;
+        for (int i = sb.length() - 1; i >= 0; i--) {
+            char c = sb.charAt(i);
+            if (curr.child[c - 'a'] == null) {
+                return false;
+            }
+            if (curr.child[c - 'a'].isEnd) {
+                return true;
+            }
+            curr = curr.child[c - 'a'];
+        }
+        return false;
+    }
+}

src/main/java/g1001_1100/s1032_stream_of_characters/readme.md

@@ -0,0 +1,42 @@
+1032\. Stream of Characters
+
+Hard
+
+Design an algorithm that accepts a stream of characters and checks if a suffix of these characters is a string of a given array of strings `words`.
+
+For example, if `words = ["abc", "xyz"]` and the stream added the four characters (one by one) `'a'`, `'x'`, `'y'`, and `'z'`, your algorithm should detect that the suffix `"xyz"` of the characters `"axyz"` matches `"xyz"` from `words`.
+
+Implement the `StreamChecker` class:
+
+*   `StreamChecker(String[] words)` Initializes the object with the strings array `words`.
+*   `boolean query(char letter)` Accepts a new character from the stream and returns `true` if any non-empty suffix from the stream forms a word that is in `words`.
+
+**Example 1:**
+
+**Input** ["StreamChecker", "query", "query", "query", "query", "query", "query", "query", "query", "query", "query", "query", "query"] [[["cd", "f", "kl"]], ["a"], ["b"], ["c"], ["d"], ["e"], ["f"], ["g"], ["h"], ["i"], ["j"], ["k"], ["l"]]
+
+**Output:** [null, false, false, false, true, false, true, false, false, false, false, false, true]
+
+**Explanation:** 
+
+    StreamChecker streamChecker = new StreamChecker(["cd", "f", "kl"]); 
+    streamChecker.query("a"); // return False 
+    streamChecker.query("b"); // return False 
+    streamChecker.query("c"); // return False 
+    streamChecker.query("d"); // return True, because 'cd' is in the wordlist 
+    streamChecker.query("e"); // return False 
+    streamChecker.query("f"); // return True, because 'f' is in the wordlist 
+    streamChecker.query("g"); // return False 
+    streamChecker.query("h"); // return False 
+    streamChecker.query("i"); // return False 
+    streamChecker.query("j"); // return False 
+    streamChecker.query("k"); // return False 
+    streamChecker.query("l"); // return True, because 'kl' is in the wordlist
+
+**Constraints:**
+
+*   `1 <= words.length <= 2000`
+*   `1 <= words[i].length <= 2000`
+*   `words[i]` consists of lowercase English letters.
+*   `letter` is a lowercase English letter.
+*   At most <code>4 * 10<sup>4</sup></code> calls will be made to query.

src/main/java/g1001_1100/s1033_moving_stones_until_consecutive/Solution.java

@@ -0,0 +1,32 @@
+package g1001_1100.s1033_moving_stones_until_consecutive;
+
+// #Medium #Math #Brainteaser #2022_02_27_Time_1_ms_(86.36%)_Space_42.7_MB_(6.82%)
+
+import java.util.Arrays;
+
+public class Solution {
+    private int minMoves(int x, int y, int z) {
+        if (x + 1 == y && y + 1 == z) {
+            return 0;
+        }
+        if (y - x <= 2 || z - y <= 2) {
+            return 1;
+        }
+
+        return 2;
+    }
+
+    private int maxMoves(int x, int z) {
+        return z - x - 2;
+    }
+
+    public int[] numMovesStones(int a, int b, int c) {
+        int[] t = {a, b, c};
+        Arrays.sort(t);
+
+        int min = minMoves(t[0], t[1], t[2]);
+        int max = maxMoves(t[0], t[2]);
+
+        return new int[] {min, max};
+    }
+}

src/main/java/g1001_1100/s1033_moving_stones_until_consecutive/readme.md

@@ -0,0 +1,43 @@
+1033\. Moving Stones Until Consecutive
+
+Medium
+
+There are three stones in different positions on the X-axis. You are given three integers `a`, `b`, and `c`, the positions of the stones.
+
+In one move, you pick up a stone at an endpoint (i.e., either the lowest or highest position stone), and move it to an unoccupied position between those endpoints. Formally, let's say the stones are currently at positions `x`, `y`, and `z` with `x < y < z`. You pick up the stone at either position `x` or position `z`, and move that stone to an integer position `k`, with `x < k < z` and `k != y`.
+
+The game ends when you cannot make any more moves (i.e., the stones are in three consecutive positions).
+
+Return _an integer array_ `answer` _of length_ `2` _where_:
+
+*   `answer[0]` _is the minimum number of moves you can play, and_
+*   `answer[1]` _is the maximum number of moves you can play_.
+
+**Example 1:**
+
+**Input:** a = 1, b = 2, c = 5
+
+**Output:** [1,2]
+
+**Explanation:** Move the stone from 5 to 3, or move the stone from 5 to 4 to 3.
+
+**Example 2:**
+
+**Input:** a = 4, b = 3, c = 2
+
+**Output:** [0,0]
+
+**Explanation:** We cannot make any moves.
+
+**Example 3:**
+
+**Input:** a = 3, b = 5, c = 1
+
+**Output:** [1,2]
+
+**Explanation:** Move the stone from 1 to 4; or move the stone from 1 to 2 to 4.
+
+**Constraints:**
+
+*   `1 <= a, b, c <= 100`
+*   `a`, `b`, and `c` have different values.

src/main/java/g1001_1100/s1034_coloring_a_border/Solution.java

@@ -0,0 +1,48 @@
+package g1001_1100.s1034_coloring_a_border;
+
+// #Medium #Array #Depth_First_Search #Breadth_First_Search #Matrix
+// #2022_02_27_Time_11_ms_(5.70%)_Space_55.1_MB_(9.60%)
+// #2022_02_27_Time_1_ms_(93.85%)_Space_55_MB_(9.60%)
+// #2022_02_27_Time_1_ms_(93.85%)_Space_55.3_MB_(9.60%)
+
+public class Solution {
+    public int[][] colorBorder(int[][] grid, int row, int col, int color) {
+        getComp(grid, row, col, color, grid[row][col]);
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] < 0) {
+                    grid[i][j] = color;
+                }
+            }
+        }
+        return grid;
+    }
+
+    private int getComp(int[][] grid, int r, int c, int color, int stColor) {
+        if (r < 0
+                || c < 0
+                || r >= grid.length
+                || c >= grid[0].length
+                || Math.abs(grid[r][c]) != stColor) {
+            return 0;
+        }
+
+        if (grid[r][c] == -stColor) {
+            return 1;
+        }
+
+        grid[r][c] = -grid[r][c];
+
+        int count = 0;
+        count += getComp(grid, r - 1, c, color, stColor);
+        count += getComp(grid, r + 1, c, color, stColor);
+        count += getComp(grid, r, c - 1, color, stColor);
+        count += getComp(grid, r, c + 1, color, stColor);
+
+        if (count == 4) {
+            grid[r][c] = -grid[r][c];
+        }
+
+        return 1;
+    }
+}

src/main/java/g1001_1100/s1034_coloring_a_border/readme.md

@@ -0,0 +1,40 @@
+1034\. Coloring A Border
+
+Medium
+
+You are given an `m x n` integer matrix `grid`, and three integers `row`, `col`, and `color`. Each value in the grid represents the color of the grid square at that location.
+
+Two squares belong to the same **connected component** if they have the same color and are next to each other in any of the 4 directions.
+
+The **border of a connected component** is all the squares in the connected component that are either **4-directionally** adjacent to a square not in the component, or on the boundary of the grid (the first or last row or column).
+
+You should color the **border** of the **connected component** that contains the square `grid[row][col]` with `color`.
+
+Return _the final grid_.
+
+**Example 1:**
+
+**Input:** grid = [[1,1],[1,2]], row = 0, col = 0, color = 3
+
+**Output:** [[3,3],[3,2]]
+
+**Example 2:**
+
+**Input:** grid = [[1,2,2],[2,3,2]], row = 0, col = 1, color = 3
+
+**Output:** [[1,3,3],[2,3,3]]
+
+**Example 3:**
+
+**Input:** grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2
+
+**Output:** [[2,2,2],[2,1,2],[2,2,2]]
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 50`
+*   `1 <= grid[i][j], color <= 1000`
+*   `0 <= row < m`
+*   `0 <= col < n`

src/main/java/g1001_1100/s1035_uncrossed_lines/Solution.java

@@ -0,0 +1,22 @@
+package g1001_1100.s1035_uncrossed_lines;
+
+// #Medium #Array #Dynamic_Programming #2022_02_27_Time_5_ms_(85.32%)_Space_45.3_MB_(5.21%)
+
+public class Solution {
+    public int maxUncrossedLines(int[] nums1, int[] nums2) {
+        int[] dp = new int[nums2.length + 1];
+        for (int i = 1; i <= nums1.length; i++) {
+            int[] dpRow = new int[nums2.length + 1];
+            for (int j = 1; j <= nums2.length; j++) {
+                if (nums1[i - 1] == nums2[j - 1]) {
+                    dpRow[j] = dp[j - 1] + 1;
+                } else {
+                    dpRow[j] = Math.max(dp[j], dpRow[j - 1]);
+                }
+            }
+            dp = dpRow;
+        }
+
+        return dp[nums2.length];
+    }
+}