Added tasks 1037, 1038, 1039, 1040

Author: ThanhNIT

README.md

@@ -1779,6 +1779,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | 1155 |[Number of Dice Rolls With Target Sum](src/main/kotlin/g1101_1200/s1155_number_of_dice_rolls_with_target_sum/Solution.kt)| Medium | Dynamic_Programming | 158 | 80.95
 | 1154 |[Day of the Year](src/main/kotlin/g1101_1200/s1154_day_of_the_year/Solution.kt)| Easy | String, Math | 317 | 70.00
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 307 | 38.36
+| 1040 |[Moving Stones Until Consecutive II](src/main/kotlin/g1001_1100/s1040_moving_stones_until_consecutive_ii/Solution.kt)| Medium | Array, Math, Sorting, Two_Pointers | 287 | 50.00
+| 1039 |[Minimum Score Triangulation of Polygon](src/main/kotlin/g1001_1100/s1039_minimum_score_triangulation_of_polygon/Solution.kt)| Medium | Array, Dynamic_Programming | 147 | 100.00
+| 1038 |[Binary Search Tree to Greater Sum Tree](src/main/kotlin/g1001_1100/s1038_binary_search_tree_to_greater_sum_tree/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 123 | 91.67
+| 1037 |[Valid Boomerang](src/main/kotlin/g1001_1100/s1037_valid_boomerang/Solution.kt)| Easy | Array, Math, Geometry | 126 | 100.00
 | 1036 |[Escape a Large Maze](src/main/kotlin/g1001_1100/s1036_escape_a_large_maze/Solution.kt)| Hard | Array, Hash_Table, Depth_First_Search, Breadth_First_Search | 387 | 100.00
 | 1035 |[Uncrossed Lines](src/main/kotlin/g1001_1100/s1035_uncrossed_lines/Solution.kt)| Medium | Array, Dynamic_Programming | 162 | 93.33
 | 1034 |[Coloring A Border](src/main/kotlin/g1001_1100/s1034_coloring_a_border/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 332 | 100.00

src/main/kotlin/g1001_1100/s1037_valid_boomerang/Solution.kt

@@ -0,0 +1,12 @@
+package g1001_1100.s1037_valid_boomerang
+
+// #Easy #Array #Math #Geometry #2023_05_26_Time_126_ms_(100.00%)_Space_34.8_MB_(60.00%)
+
+class Solution {
+    fun isBoomerang(points: Array<IntArray>): Boolean {
+        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/kotlin/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/kotlin/g1001_1100/s1038_binary_search_tree_to_greater_sum_tree/Solution.kt

@@ -0,0 +1,31 @@
+package g1001_1100.s1038_binary_search_tree_to_greater_sum_tree
+
+// #Medium #Depth_First_Search #Tree #Binary_Tree #Binary_Search_Tree
+// #2023_05_26_Time_123_ms_(91.67%)_Space_34.7_MB_(58.33%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private var greaterSum = 0
+    fun bstToGst(root: TreeNode?): TreeNode {
+        if (root!!.right != null) {
+            bstToGst(root.right!!)
+        }
+        root.`val` = greaterSum + root.`val`
+        greaterSum = root.`val`
+        if (root.left != null) {
+            bstToGst(root.left!!)
+        }
+        return root
+    }
+}

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

@@ -0,0 +1,33 @@
+1038\. Binary Search Tree to Greater Sum Tree
+
+Medium
+
+Given the `root` of a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus the sum of all keys greater than the original key in BST.
+
+As a reminder, a _binary search tree_ is a tree that satisfies these constraints:
+
+*   The left subtree of a node contains only nodes with keys **less than** the node's key.
+*   The right subtree of a node contains only nodes with keys **greater than** the node's key.
+*   Both the left and right subtrees must also be binary search trees.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/05/02/tree.png)
+
+**Input:** root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
+
+**Output:** [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
+
+**Example 2:**
+
+**Input:** root = [0,null,1]
+
+**Output:** [1,null,1]
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 100]`.
+*   `0 <= Node.val <= 100`
+*   All the values in the tree are **unique**.
+
+**Note:** This question is the same as 538: [https://leetcode.com/problems/convert-bst-to-greater-tree/](https://leetcode.com/problems/convert-bst-to-greater-tree/)

src/main/kotlin/g1001_1100/s1039_minimum_score_triangulation_of_polygon/Solution.kt

@@ -0,0 +1,34 @@
+package g1001_1100.s1039_minimum_score_triangulation_of_polygon
+
+// #Medium #Array #Dynamic_Programming #2023_05_26_Time_147_ms_(100.00%)_Space_38.9_MB_(50.00%)
+
+class Solution() {
+    private val dp = Array(101) { IntArray(101) }
+    fun minScoreTriangulation(values: IntArray): Int {
+        val n = values.size
+        for (row: IntArray? in dp) {
+            row!!.fill(-1)
+        }
+        return util(values, 1, n - 1)
+    }
+
+    private fun util(values: IntArray, i: Int, j: Int): Int {
+        if (i >= j) {
+            return 0
+        }
+        if (dp[i][j] != -1) {
+            return dp[i][j]
+        }
+        var ans = Int.MAX_VALUE
+        for (k in i until j) {
+            val temp = (
+                util(values, i, k) +
+                    util(values, k + 1, j) +
+                    (values[i - 1] * values[k] * values[j])
+                )
+            ans = ans.coerceAtMost(temp)
+            dp[i][j] = ans
+        }
+        return dp[i][j]
+    }
+}

src/main/kotlin/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/kotlin/g1001_1100/s1040_moving_stones_until_consecutive_ii/Solution.kt

@@ -0,0 +1,20 @@
+package g1001_1100.s1040_moving_stones_until_consecutive_ii
+
+// #Medium #Array #Math #Sorting #Two_Pointers
+// #2023_05_26_Time_287_ms_(50.00%)_Space_50.2_MB_(100.00%)
+
+class Solution {
+    fun numMovesStonesII(a: IntArray): IntArray? {
+        a.sort()
+        var i = 0
+        val n = a.size
+        var low = n
+        val high = (a[n - 1] - n + 2 - a[1]).coerceAtLeast(a[n - 2] - a[0] - n + 2)
+        for (j in 0 until n) {
+            while (a[j] - a[i] >= n) ++i
+            low = if (j - i + 1 == n - 1 && a[j] - a[i] == n - 2) low.coerceAtMost(2)
+            else low.coerceAtMost(n - (j - i + 1))
+        }
+        return intArrayOf(low, high)
+    }
+}

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

@@ -0,0 +1,38 @@
+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**.

src/test/kotlin/g1001_1100/s1037_valid_boomerang/SolutionTest.kt

@@ -0,0 +1,19 @@
+package g1001_1100.s1037_valid_boomerang
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isBoomerang() {
+        assertThat(Solution().isBoomerang(arrayOf(intArrayOf(1, 1), intArrayOf(2, 3), intArrayOf(3, 2))), equalTo(true))
+    }
+
+    @Test
+    fun isBoomerang2() {
+        assertThat(
+            Solution().isBoomerang(arrayOf(intArrayOf(1, 1), intArrayOf(2, 2), intArrayOf(3, 3))), equalTo(false)
+        )
+    }
+}