Added tasks 1036, 1037, 1038, 1039, 1040.

Author: ThanhNIT

src/main/java/g1001_1100/s1036_escape_a_large_maze/Solution.java

@@ -0,0 +1,46 @@
+package g1001_1100.s1036_escape_a_large_maze;
+
+// #Hard #Array #Hash_Table #Depth_First_Search #Breadth_First_Search
+// #2022_02_27_Time_115_ms_(73.46%)_Space_79.4_MB_(60.66%)
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution {
+    public boolean isEscapePossible(int[][] blocked, int[] source, int[] target) {
+        if (blocked.length == 0) {
+            return true;
+        }
+        Set<Integer> blocks = new HashSet<>();
+        for (int[] b : blocked) {
+            if (target[0] * 1000000 + target[1] != b[0] * 1000000 + b[1]) {
+                blocks.add(b[0] * 1000000 + b[1]);
+            }
+        }
+        return dfs(blocks, source, source[0], source[1], new HashSet<>(), target)
+                && dfs(blocks, target, target[0], target[1], new HashSet<>(), source);
+    }
+
+    private boolean dfs(
+            Set<Integer> blocks, int[] start, int i, int j, Set<Integer> visited, int[] target) {
+        if (i < 0
+                || j < 0
+                || i > 999999
+                || j > 999999
+                || blocks.contains(i * 1000000 + j)
+                || visited.contains(i * 1000000 + j)) {
+            return false;
+        }
+        if (i == target[0] && j == target[1]) {
+            return true;
+        }
+        visited.add(i * 1000000 + j);
+        if (visited.size() > blocks.size() * (blocks.size() + 1)) {
+            return true;
+        }
+        return dfs(blocks, start, i + 1, j, visited, target)
+                || dfs(blocks, start, i - 1, j, visited, target)
+                || dfs(blocks, start, i, j + 1, visited, target)
+                || dfs(blocks, start, i, j - 1, visited, target);
+    }
+}

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

@@ -0,0 +1,41 @@
+1036\. Escape a Large Maze
+
+Hard
+
+There is a 1 million by 1 million grid on an XY-plane, and the coordinates of each grid square are `(x, y)`.
+
+We start at the <code>source = [s<sub>x</sub>, s<sub>y</sub>]</code> square and want to reach the <code>target = [t<sub>x</sub>, t<sub>y</sub>]</code> square. There is also an array of `blocked` squares, where each <code>blocked[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a blocked square with coordinates <code>(x<sub>i</sub>, y<sub>i</sub>)</code>.
+
+Each move, we can walk one square north, east, south, or west if the square is **not** in the array of `blocked` squares. We are also not allowed to walk outside of the grid.
+
+Return `true` _if and only if it is possible to reach the_ `target` _square from the_ `source` _square through a sequence of valid moves_.
+
+**Example 1:**
+
+**Input:** blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
+
+**Output:** false
+
+**Explanation:** The target square is inaccessible starting from the source square because we cannot move. 
+
+We cannot move north or east because those squares are blocked. 
+
+We cannot move south or west because we cannot go outside of the grid.
+
+**Example 2:**
+
+**Input:** blocked = [], source = [0,0], target = [999999,999999]
+
+**Output:** true
+
+**Explanation:** Because there are no blocked cells, it is possible to reach the target square.
+
+**Constraints:**
+
+*   `0 <= blocked.length <= 200`
+*   `blocked[i].length == 2`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> < 10<sup>6</sup></code>
+*   `source.length == target.length == 2`
+*   <code>0 <= s<sub>x</sub>, s<sub>y</sub>, t<sub>x</sub>, t<sub>y</sub> < 10<sup>6</sup></code>
+*   `source != target`
+*   It is guaranteed that `source` and `target` are not blocked.

src/main/java/g1001_1100/s1037_valid_boomerang/Solution.java

@@ -0,0 +1,10 @@
+package g1001_1100.s1037_valid_boomerang;
+
+// #Easy #Math #Geometry #2022_02_27_Time_0_ms_(100.00%)_Space_41.7_MB_(21.15%)
+
+public class Solution {
+    public boolean isBoomerang(int[][] points) {
+        return (points[1][1] - points[0][1]) * (points[2][0] - points[0][0])
+                != (points[2][1] - points[0][1]) * (points[1][0] - points[0][0]);
+    }
+}

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

@@ -0,0 +1,25 @@
+1037\. Valid Boomerang
+
+Easy
+
+Given an array `points` where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a point on the **X-Y** plane, return `true` _if these points are a **boomerang**_.
+
+A **boomerang** is a set of three points that are **all distinct** and **not in a straight line**.
+
+**Example 1:**
+
+**Input:** points = [[1,1],[2,3],[3,2]]
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** points = [[1,1],[2,2],[3,3]]
+
+**Output:** false
+
+**Constraints:**
+
+*   `points.length == 3`
+*   `points[i].length == 2`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 100</code>

src/main/java/g1001_1100/s1038_binary_search_tree_to_greater_sum_tree/Solution.java

@@ -0,0 +1,21 @@
+package g1001_1100.s1038_binary_search_tree_to_greater_sum_tree;
+
+// #Medium #Depth_First_Search #Tree #Binary_Tree #Binary_Search_Tree
+// #2022_02_27_Time_0_ms_(100.00%)_Space_42.2_MB_(6.86%)
+
+import com_github_leetcode.TreeNode;
+
+public class Solution {
+    private int greaterSum = 0;
+
+    public TreeNode bstToGst(TreeNode root) {
+        if (root.right != null) {
+            bstToGst(root.right);
+        }
+        greaterSum = root.val = greaterSum + root.val;
+        if (root.left != null) {
+            bstToGst(root.left);
+        }
+        return root;
+    }
+}

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

@@ -0,0 +1,25 @@
+1037\. Valid Boomerang
+
+Easy
+
+Given an array `points` where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a point on the **X-Y** plane, return `true` _if these points are a **boomerang**_.
+
+A **boomerang** is a set of three points that are **all distinct** and **not in a straight line**.
+
+**Example 1:**
+
+**Input:** points = [[1,1],[2,3],[3,2]]
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** points = [[1,1],[2,2],[3,3]]
+
+**Output:** false
+
+**Constraints:**
+
+*   `points.length == 3`
+*   `points[i].length == 2`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= 100</code>

src/main/java/g1001_1100/s1039_minimum_score_triangulation_of_polygon/Solution.java

@@ -0,0 +1,41 @@
+package g1001_1100.s1039_minimum_score_triangulation_of_polygon;
+
+// #Medium #Array #Dynamic_Programming #2022_02_27_Time_6_ms_(38.60%)_Space_42.2_MB_(8.48%)
+
+import java.util.Arrays;
+
+public class Solution {
+
+    private static final int[][] DP = new int[101][101];
+
+    public int minScoreTriangulation(int[] values) {
+        int n = values.length;
+        for (int[] row : DP) {
+            Arrays.fill(row, -1);
+        }
+        return util(values, 1, n - 1);
+    }
+
+    private int util(int[] values, int i, int j) {
+        if (i >= j) {
+            return 0;
+        }
+        if (DP[i][j] != -1) {
+            return DP[i][j];
+        }
+
+        int ans = Integer.MAX_VALUE;
+
+        for (int k = i; k <= j - 1; k++) {
+            int temp =
+                    util(values, i, k)
+                            + util(values, k + 1, j)
+                            + (values[i - 1] * values[k] * values[j]);
+
+            ans = Math.min(ans, temp);
+            DP[i][j] = ans;
+        }
+
+        return DP[i][j];
+    }
+}

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

@@ -0,0 +1,45 @@
+1039\. Minimum Score Triangulation of Polygon
+
+Medium
+
+You have a convex `n`\-sided polygon where each vertex has an integer value. You are given an integer array `values` where `values[i]` is the value of the <code>i<sup>th</sup></code> vertex (i.e., **clockwise order**).
+
+You will **triangulate** the polygon into `n - 2` triangles. For each triangle, the value of that triangle is the product of the values of its vertices, and the total score of the triangulation is the sum of these values over all `n - 2` triangles in the triangulation.
+
+Return _the smallest possible total score that you can achieve with some triangulation of the polygon_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/25/shape1.jpg)
+
+**Input:** values = [1,2,3]
+
+**Output:** 6
+
+**Explanation:** The polygon is already triangulated, and the score of the only triangle is 6.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/25/shape2.jpg)
+
+**Input:** values = [3,7,4,5]
+
+**Output:** 144
+
+**Explanation:** There are two triangulations, with possible scores: 3\*7\*5 + 4\*5\*7 = 245, or 3\*4\*5 + 3\*4\*7 = 144. The minimum score is 144.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/02/25/shape3.jpg)
+
+**Input:** values = [1,3,1,4,1,5]
+
+**Output:** 13
+
+**Explanation:** The minimum score triangulation has score 1\*1\*3 + 1\*1\*4 + 1\*1\*5 + 1\*1\*1 = 13.
+
+**Constraints:**
+
+*   `n == values.length`
+*   `3 <= n <= 50`
+*   `1 <= values[i] <= 100`

src/main/java/g1001_1100/s1040_moving_stones_until_consecutive_ii/Solution.java

@@ -0,0 +1,47 @@
+package g1001_1100.s1040_moving_stones_until_consecutive_ii;
+
+// #Medium #Array #Math #Sorting #Two_Pointers #2022_02_27_Time_8_ms_(55.00%)_Space_49_MB_(31.67%)
+
+import java.util.Arrays;
+
+public class Solution {
+    public int[] numMovesStonesII(int[] stones) {
+        int n = stones.length;
+        int[] ans = new int[2];
+        int i = 0;
+        int j = 0;
+        int wsize;
+        int scount;
+        int minMoves = Integer.MAX_VALUE;
+        Arrays.sort(stones);
+        while (j < n) {
+            wsize = stones[j] - stones[i] + 1;
+            scount = j - i + 1;
+            if (wsize > n) {
+                i++;
+                continue;
+            }
+
+            if (wsize == n - 1 && scount == n - 1) {
+                minMoves = Math.min(minMoves, 2);
+            } else {
+                minMoves = Math.min(minMoves, n - scount);
+            }
+
+            j++;
+        }
+        ans[0] = minMoves;
+        int maxMoves = 0;
+        if (stones[1] == stones[0] + 1 || stones[n - 1] == stones[n - 2] + 1) {
+            maxMoves = stones[n - 1] - stones[0] + 1 - n;
+        } else {
+            maxMoves =
+                    Math.max(
+                            ((stones[n - 1] - stones[1]) - (n - 1) + 1),
+                            ((stones[n - 2] - stones[0]) - (n - 1) + 1));
+        }
+
+        ans[1] = maxMoves;
+        return ans;
+    }
+}

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

@@ -0,0 +1,42 @@
+1040\. Moving Stones Until Consecutive II
+
+Medium
+
+There are some stones in different positions on the X-axis. You are given an integer array `stones`, the positions of the stones.
+
+Call a stone an **endpoint stone** if it has the smallest or largest position. In one move, you pick up an **endpoint stone** and move it to an unoccupied position so that it is no longer an **endpoint stone**.
+
+*   In particular, if the stones are at say, `stones = [1,2,5]`, you cannot move the endpoint stone at position `5`, since moving it to any position (such as `0`, or `3`) will still keep that stone as an endpoint stone.
+
+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:** stones = [7,4,9]
+
+**Output:** [1,2]
+
+**Explanation:** We can move 4 -> 8 for one move to finish the game. Or, we can move 9 -> 5, 4 -> 6 for two moves to finish the game.
+
+**Example 2:**
+
+**Input:** stones = [6,5,4,3,10]
+
+**Output:** [2,3]
+
+**Explanation:** We can move 3 -> 8 then 10 -> 7 to finish the game. 
+
+Or, we can move 3 -> 7, 4 -> 8, 5 -> 9 to finish the game. 
+
+Notice we cannot move 10 -> 2 to finish the game, because that would be an illegal move.
+
+**Constraints:**
+
+*   <code>3 <= stones.length <= 10<sup>4</sup></code>
+*   <code>1 <= stones[i] <= 10<sup>9</sup></code>
+*   All the values of `stones` are **unique**.