Added tasks 1041, 1042, 1043, 1044

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
+| 1044 |[Longest Duplicate Substring](src/main/kotlin/g1001_1100/s1044_longest_duplicate_substring/Solution.kt)| Hard | String, Binary_Search, Sliding_Window, Hash_Function, Rolling_Hash, Suffix_Array | 592 | 100.00
+| 1043 |[Partition Array for Maximum Sum](src/main/kotlin/g1001_1100/s1043_partition_array_for_maximum_sum/Solution.kt)| Medium | Array, Dynamic_Programming | 194 | 71.43
+| 1042 |[Flower Planting With No Adjacent](src/main/kotlin/g1001_1100/s1042_flower_planting_with_no_adjacent/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph | 396 | 85.71
+| 1041 |[Robot Bounded In Circle](src/main/kotlin/g1001_1100/s1041_robot_bounded_in_circle/Solution.kt)| Medium | String, Math, Simulation | 121 | 100.00
 | 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

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

@@ -0,0 +1,23 @@
+package g1001_1100.s1041_robot_bounded_in_circle
+
+// #Medium #String #Math #Simulation #2023_05_27_Time_121_ms_(100.00%)_Space_34.3_MB_(66.67%)
+
+class Solution {
+    fun isRobotBounded(instructions: String): Boolean {
+        val dir = arrayOf(intArrayOf(0, 1), intArrayOf(-1, 0), intArrayOf(0, -1), intArrayOf(1, 0))
+        var i = 0
+        var x = 0
+        var y = 0
+        for (s in instructions.indices) {
+            if (instructions[s] == 'L') {
+                i = (i + 1) % 4
+            } else if (instructions[s] == 'R') {
+                i = (i + 3) % 4
+            } else {
+                x += dir[i][0]
+                y += dir[i][1]
+            }
+        }
+        return x == 0 && y == 0 || i != 0
+    }
+}

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

@@ -0,0 +1,93 @@
+1041\. Robot Bounded In Circle
+
+Medium
+
+On an infinite plane, a robot initially stands at `(0, 0)` and faces north. Note that:
+
+*   The **north direction** is the positive direction of the y-axis.
+*   The **south direction** is the negative direction of the y-axis.
+*   The **east direction** is the positive direction of the x-axis.
+*   The **west direction** is the negative direction of the x-axis.
+
+The robot can receive one of three instructions:
+
+*   `"G"`: go straight 1 unit.
+*   `"L"`: turn 90 degrees to the left (i.e., anti-clockwise direction).
+*   `"R"`: turn 90 degrees to the right (i.e., clockwise direction).
+
+The robot performs the `instructions` given in order, and repeats them forever.
+
+Return `true` if and only if there exists a circle in the plane such that the robot never leaves the circle.
+
+**Example 1:**
+
+**Input:** instructions = "GGLLGG"
+
+**Output:** true
+
+**Explanation:** The robot is initially at (0, 0) facing the north direction.
+
+"G": move one step. Position: (0, 1). Direction: North.
+
+"G": move one step. Position: (0, 2). Direction: North.
+
+"L": turn 90 degrees anti-clockwise. Position: (0, 2). Direction: West.
+
+"L": turn 90 degrees anti-clockwise. Position: (0, 2). Direction: South.
+
+"G": move one step. Position: (0, 1). Direction: South.
+
+"G": move one step. Position: (0, 0). Direction: South.
+
+Repeating the instructions, the robot goes into the cycle: (0, 0) --> (0, 1) --> (0, 2) --> (0, 1) --> (0, 0).
+
+Based on that, we return true.
+
+**Example 2:**
+
+**Input:** instructions = "GG"
+
+**Output:** false
+
+**Explanation:** The robot is initially at (0, 0) facing the north direction.
+
+"G": move one step. Position: (0, 1). Direction: North.
+
+"G": move one step. Position: (0, 2). Direction: North.
+
+Repeating the instructions, keeps advancing in the north direction and does not go into cycles.
+
+Based on that, we return false.
+
+**Example 3:**
+
+**Input:** instructions = "GL"
+
+**Output:** true
+
+**Explanation:** The robot is initially at (0, 0) facing the north direction.
+
+"G": move one step. Position: (0, 1). Direction: North.
+
+"L": turn 90 degrees anti-clockwise. Position: (0, 1). Direction: West.
+
+"G": move one step. Position: (-1, 1). Direction: West.
+
+"L": turn 90 degrees anti-clockwise. Position: (-1, 1). Direction: South.
+
+"G": move one step. Position: (-1, 0). Direction: South.
+
+"L": turn 90 degrees anti-clockwise. Position: (-1, 0). Direction: East.
+
+"G": move one step. Position: (0, 0). Direction: East.
+
+"L": turn 90 degrees anti-clockwise. Position: (0, 0). Direction: North.
+
+Repeating the instructions, the robot goes into the cycle: (0, 0) --> (0, 1) --> (-1, 1) --> (-1, 0) --> (0, 0).
+
+Based on that, we return true.
+
+**Constraints:**
+
+*   `1 <= instructions.length <= 100`
+*   `instructions[i]` is `'G'`, `'L'` or, `'R'`.

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

@@ -0,0 +1,53 @@
+package g1001_1100.s1042_flower_planting_with_no_adjacent
+
+// #Medium #Depth_First_Search #Breadth_First_Search #Graph
+// #2023_05_27_Time_396_ms_(85.71%)_Space_82.5_MB_(42.86%)
+
+class Solution {
+    private lateinit var graph: Array<ArrayList<Int>?>
+    private lateinit var color: IntArray
+    private lateinit var visited: BooleanArray
+
+    fun gardenNoAdj(n: Int, paths: Array<IntArray>): IntArray {
+        buildGraph(n, paths)
+        color = IntArray(n)
+        visited = BooleanArray(n)
+        for (i in 0 until n) {
+            if (!visited[i]) {
+                dfs(i)
+            }
+        }
+        return color
+    }
+
+    private fun dfs(at: Int) {
+        visited[at] = true
+        var used = 0
+        for (to in graph[at]!!) {
+            if (color[to] != 0) {
+                used = used or (1 shl color[to] - 1)
+            }
+        }
+
+        // use available color
+        for (i in 0..3) {
+            if (used and (1 shl i) == 0) {
+                color[at] = i + 1
+                break
+            }
+        }
+    }
+
+    private fun buildGraph(n: Int, paths: Array<IntArray>) {
+        graph = arrayOfNulls(n)
+        for (i in 0 until n) {
+            graph[i] = ArrayList()
+        }
+        for (path in paths) {
+            val u = path[0] - 1
+            val v = path[1] - 1
+            graph[u]!!.add(v)
+            graph[v]!!.add(u)
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+1042\. Flower Planting With No Adjacent
+
+Medium
+
+You have `n` gardens, labeled from `1` to `n`, and an array `paths` where <code>paths[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> describes a bidirectional path between garden <code>x<sub>i</sub></code> to garden <code>y<sub>i</sub></code>. In each garden, you want to plant one of 4 types of flowers.
+
+All gardens have **at most 3** paths coming into or leaving it.
+
+Your task is to choose a flower type for each garden such that, for any two gardens connected by a path, they have different types of flowers.
+
+Return _**any** such a choice as an array_ `answer`_, where_ `answer[i]` _is the type of flower planted in the_ <code>(i+1)<sup>th</sup></code> _garden. The flower types are denoted_ `1`_,_ `2`_,_ `3`_, or_ `4`_. It is guaranteed an answer exists._
+
+**Example 1:**
+
+**Input:** n = 3, paths = [[1,2],[2,3],[3,1]]
+
+**Output:** [1,2,3]
+
+**Explanation:** 
+
+Gardens 1 and 2 have different types. 
+
+Gardens 2 and 3 have different types. 
+
+Gardens 3 and 1 have different types. 
+
+Hence, [1,2,3] is a valid answer. Other valid answers include [1,2,4], [1,4,2], and [3,2,1].
+
+**Example 2:**
+
+**Input:** n = 4, paths = [[1,2],[3,4]]
+
+**Output:** [1,2,1,2]
+
+**Example 3:**
+
+**Input:** n = 4, paths = [[1,2],[2,3],[3,4],[4,1],[1,3],[2,4]]
+
+**Output:** [1,2,3,4]
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>4</sup></code>
+*   <code>0 <= paths.length <= 2 * 10<sup>4</sup></code>
+*   `paths[i].length == 2`
+*   <code>1 <= x<sub>i</sub>, y<sub>i</sub> <= n</code>
+*   <code>x<sub>i</sub> != y<sub>i</sub></code>
+*   Every garden has **at most 3** paths coming into or leaving it.

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

@@ -0,0 +1,22 @@
+package g1001_1100.s1043_partition_array_for_maximum_sum
+
+// #Medium #Array #Dynamic_Programming #2023_05_27_Time_194_ms_(71.43%)_Space_38.2_MB_(57.14%)
+
+class Solution {
+    fun maxSumAfterPartitioning(arr: IntArray, k: Int): Int {
+        val n = arr.size
+        val dp = IntArray(n)
+        for (right in 0 until n) {
+            var localMax = arr[right]
+            for (left in right downTo (-1).coerceAtLeast(right - k) + 1) {
+                localMax = localMax.coerceAtLeast(arr[left])
+                if (left == 0) {
+                    dp[right] = dp[right].coerceAtLeast((right + 1) * localMax)
+                } else {
+                    dp[right] = dp[right].coerceAtLeast(dp[left - 1] + (right - left + 1) * localMax)
+                }
+            }
+        }
+        return dp[n - 1]
+    }
+}

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

@@ -0,0 +1,33 @@
+1043\. Partition Array for Maximum Sum
+
+Medium
+
+Given an integer array `arr`, partition the array into (contiguous) subarrays of length **at most** `k`. After partitioning, each subarray has their values changed to become the maximum value of that subarray.
+
+Return _the largest sum of the given array after partitioning. Test cases are generated so that the answer fits in a **32-bit** integer._
+
+**Example 1:**
+
+**Input:** arr = [1,15,7,9,2,5,10], k = 3
+
+**Output:** 84
+
+**Explanation:** arr becomes [15,15,15,9,10,10,10]
+
+**Example 2:**
+
+**Input:** arr = [1,4,1,5,7,3,6,1,9,9,3], k = 4
+
+**Output:** 83
+
+**Example 3:**
+
+**Input:** arr = [1], k = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= arr.length <= 500`
+*   <code>0 <= arr[i] <= 10<sup>9</sup></code>
+*   `1 <= k <= arr.length`

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

@@ -0,0 +1,68 @@
+package g1001_1100.s1044_longest_duplicate_substring
+
+// #Hard #String #Binary_Search #Sliding_Window #Hash_Function #Rolling_Hash #Suffix_Array
+// #2023_05_27_Time_592_ms_(100.00%)_Space_106.4_MB_(100.00%)
+
+class Solution {
+    private lateinit var hsh: LongArray
+    private lateinit var pw: LongArray
+    private val cnt: Array<MutableList<Int>?> = arrayOfNulls(26)
+
+    fun longestDupSubstring(s: String): String {
+        val n = s.length
+        val base = 131
+        for (i in 0..25) {
+            cnt[i] = ArrayList()
+        }
+        hsh = LongArray(n + 1)
+        pw = LongArray(n + 1)
+        pw[0] = 1
+        for (j in 1..n) {
+            hsh[j] = (hsh[j - 1] * base + s[j - 1].code.toLong()) % MOD
+            pw[j] = pw[j - 1] * base % MOD
+            cnt[s[j - 1].code - 'a'.code]!!.add(j - 1)
+        }
+        var ans = ""
+        for (i in 0..25) {
+            if (cnt[i]!!.isEmpty()) {
+                continue
+            }
+            val idx: MutableList<Int>? = cnt[i]
+            var set: MutableSet<Long?>
+            var lo = 1
+            var hi = n - idx!![0]
+            while (lo <= hi) {
+                val len = (lo + hi) / 2
+                set = HashSet()
+                var found = false
+                for (nxt in idx) {
+                    if (nxt + len <= n) {
+                        val substrHash = getSubstrHash(nxt, nxt + len)
+                        if (set.contains(substrHash)) {
+                            found = true
+                            if (len + 1 > ans.length) {
+                                ans = s.substring(nxt, nxt + len)
+                            }
+                            break
+                        }
+                        set.add(substrHash)
+                    }
+                }
+                if (found) {
+                    lo = len + 1
+                } else {
+                    hi = len - 1
+                }
+            }
+        }
+        return ans
+    }
+
+    private fun getSubstrHash(l: Int, r: Int): Long {
+        return (hsh[r] - hsh[l] * pw[r - l] % MOD + MOD) % MOD
+    }
+
+    companion object {
+        private const val MOD = 1e9.toInt() + 7
+    }
+}

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

@@ -0,0 +1,24 @@
+1044\. Longest Duplicate Substring
+
+Hard
+
+Given a string `s`, consider all _duplicated substrings_: (contiguous) substrings of s that occur 2 or more times. The occurrences may overlap.
+
+Return **any** duplicated substring that has the longest possible length. If `s` does not have a duplicated substring, the answer is `""`.
+
+**Example 1:**
+
+**Input:** s = "banana"
+
+**Output:** "ana"
+
+**Example 2:**
+
+**Input:** s = "abcd"
+
+**Output:** ""
+
+**Constraints:**
+
+*   <code>2 <= s.length <= 3 * 10<sup>4</sup></code>
+*   `s` consists of lowercase English letters.