Added tasks 1029, 1030, 1031, 1032

Author: ThanhNIT

README.md

@@ -1750,6 +1750,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
 | 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
+| 1032 |[Maximum Sum of Two Non-Overlapping Subarrays](src/main/kotlin/g1001_1100/s1032_stream_of_characters/StreamChecker.kt)| Hard | Array, String, Design, Trie, Data_Stream | 733 | 100.00
+| 1031 |[Maximum Sum of Two Non-Overlapping Subarrays](src/main/kotlin/g1001_1100/s1031_maximum_sum_of_two_non_overlapping_subarrays/Solution.kt)| Medium | Array, Dynamic_Programming, Sliding_Window | 172 | 100.00
+| 1030 |[Matrix Cells in Distance Order](src/main/kotlin/g1001_1100/s1030_matrix_cells_in_distance_order/Solution.kt)| Easy | Array, Math, Sorting, Matrix, Geometry | 426 | 100.00
+| 1029 |[Two City Scheduling](src/main/kotlin/g1001_1100/s1029_two_city_scheduling/Solution.kt)| Medium | Array, Sorting, Greedy | 148 | 100.00
 | 1028 |[Recover a Tree From Preorder Traversal](src/main/kotlin/g1001_1100/s1028_recover_a_tree_from_preorder_traversal/Solution.kt)| Hard | String, Depth_First_Search, Tree, Binary_Tree | 246 | 100.00
 | 1027 |[Longest Arithmetic Subsequence](src/main/kotlin/g1001_1100/s1027_longest_arithmetic_subsequence/Solution.kt)| Medium | Array, Hash_Table, Dynamic_Programming, Binary_Search | 330 | 100.00
 | 1026 |[Maximum Difference Between Node and Ancestor](src/main/kotlin/g1001_1100/s1026_maximum_difference_between_node_and_ancestor/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree | 155 | 77.78

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

@@ -0,0 +1,22 @@
+package g1001_1100.s1029_two_city_scheduling
+
+// #Medium #Array #Sorting #Greedy #2023_05_24_Time_148_ms_(100.00%)_Space_35.4_MB_(92.31%)
+
+import java.util.Arrays
+
+class Solution {
+    fun twoCitySchedCost(costs: Array<IntArray>): Int {
+        Arrays.sort(costs) { a: IntArray, b: IntArray ->
+            a[0] - a[1] - (b[0] - b[1])
+        }
+        var cost = 0
+        for (i in costs.indices) {
+            cost += if (i < costs.size / 2) {
+                costs[i][0]
+            } else {
+                costs[i][1]
+            }
+        }
+        return cost
+    }
+}

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

@@ -0,0 +1,44 @@
+1029\. Two City Scheduling
+
+Medium
+
+A company is planning to interview `2n` people. Given the array `costs` where <code>costs[i] = [aCost<sub>i</sub>, bCost<sub>i</sub>]</code>, the cost of flying the <code>i<sup>th</sup></code> person to city `a` is <code>aCost<sub>i</sub></code>, and the cost of flying the <code>i<sup>th</sup></code> person to city `b` is <code>bCost<sub>i</sub></code>.
+
+Return _the minimum cost to fly every person to a city_ such that exactly `n` people arrive in each city.
+
+**Example 1:**
+
+**Input:** costs = [[10,20],[30,200],[400,50],[30,20]]
+
+**Output:** 110
+
+**Explanation:**  
+
+The first person goes to city A for a cost of 10. 
+
+The second person goes to city A for a cost of 30. 
+
+The third person goes to city B for a cost of 50. 
+
+The fourth person goes to city B for a cost of 20.
+
+The total minimum cost is 10 + 30 + 50 + 20 = 110 to have half the people interviewing in each city.
+
+**Example 2:**
+
+**Input:** costs = [[259,770],[448,54],[926,667],[184,139],[840,118],[577,469]]
+
+**Output:** 1859
+
+**Example 3:**
+
+**Input:** costs = [[515,563],[451,713],[537,709],[343,819],[855,779],[457,60],[650,359],[631,42]]
+
+**Output:** 3086
+
+**Constraints:**
+
+*   `2 * n == costs.length`
+*   `2 <= costs.length <= 100`
+*   `costs.length` is even.
+*   <code>1 <= aCost<sub>i</sub>, bCost<sub>i</sub> <= 1000</code>

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

@@ -0,0 +1,29 @@
+package g1001_1100.s1030_matrix_cells_in_distance_order
+
+// #Easy #Array #Math #Sorting #Matrix #Geometry
+// #2023_05_24_Time_426_ms_(100.00%)_Space_99.9_MB_(100.00%)
+
+import java.util.TreeMap
+import kotlin.math.abs
+
+class Solution {
+    fun allCellsDistOrder(rows: Int, cols: Int, rCenter: Int, cCenter: Int): Array<IntArray?> {
+        val map: MutableMap<Int, MutableList<IntArray>> = TreeMap()
+        for (i in 0 until rows) {
+            for (j in 0 until cols) {
+                map.computeIfAbsent(
+                    abs(i - rCenter) + abs(j - cCenter)
+                ) { ArrayList() }
+                    .add(intArrayOf(i, j))
+            }
+        }
+        val res = arrayOfNulls<IntArray>(rows * cols)
+        var i = 0
+        for (list in map.values) {
+            for (each in list) {
+                res[i++] = each
+            }
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,39 @@
+1030\. Matrix Cells in Distance Order
+
+Easy
+
+You are given four integers `row`, `cols`, `rCenter`, and `cCenter`. There is a `rows x cols` matrix and you are on the cell with the coordinates `(rCenter, cCenter)`.
+
+Return _the coordinates of all cells in the matrix, sorted by their **distance** from_ `(rCenter, cCenter)` _from the smallest distance to the largest distance_. You may return the answer in **any order** that satisfies this condition.
+
+The **distance** between two cells <code>(r<sub>1</sub>, c<sub>1</sub>)</code> and <code>(r<sub>2</sub>, c<sub>2</sub>)</code> is <code>|r<sub>1</sub> - r<sub>2</sub>| + |c<sub>1</sub> - c<sub>2</sub>|</code>.
+
+**Example 1:**
+
+**Input:** rows = 1, cols = 2, rCenter = 0, cCenter = 0
+
+**Output:** [[0,0],[0,1]]
+
+**Explanation:** The distances from (0, 0) to other cells are: [0,1]
+
+**Example 2:**
+
+**Input:** rows = 2, cols = 2, rCenter = 0, cCenter = 1
+
+**Output:** [[0,1],[0,0],[1,1],[1,0]]
+
+**Explanation:** The distances from (0, 1) to other cells are: [0,1,1,2] The answer [[0,1],[1,1],[0,0],[1,0]] would also be accepted as correct.
+
+**Example 3:**
+
+**Input:** rows = 2, cols = 3, rCenter = 1, cCenter = 2
+
+**Output:** [[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
+
+**Explanation:** The distances from (1, 2) to other cells are: [0,1,1,2,2,3] There are other answers that would also be accepted as correct, such as [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]].
+
+**Constraints:**
+
+*   `1 <= rows, cols <= 100`
+*   `0 <= rCenter < rows`
+*   `0 <= cCenter < cols`

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

@@ -0,0 +1,62 @@
+package g1001_1100.s1031_maximum_sum_of_two_non_overlapping_subarrays
+
+// #Medium #Array #Dynamic_Programming #Sliding_Window
+// #2023_05_24_Time_172_ms_(100.00%)_Space_36.7_MB_(100.00%)
+
+class Solution {
+    fun maxSumTwoNoOverlap(nums: IntArray, firstLen: Int, secondLen: Int): Int {
+        val firstLenSum = getFirstLenSums(nums, firstLen)
+        return getMaxLenSum(nums, secondLen, firstLenSum)
+    }
+
+    private fun getMaxLenSum(nums: IntArray, secondLen: Int, firstLenSum: Array<IntArray>): Int {
+        var maxSum = 0
+        var currentSum = 0
+        var onRight: Int
+        for (i in 0 until secondLen) {
+            currentSum += nums[i]
+        }
+        onRight = firstLenSum[1][secondLen]
+        maxSum = maxSum.coerceAtLeast(currentSum + onRight)
+        var i = 1
+        var j = secondLen
+        while (j < nums.size) {
+            currentSum = currentSum - nums[i - 1] + nums[j]
+            onRight = if (j < nums.size - 1) firstLenSum[1][j + 1] else 0
+            maxSum = maxSum.coerceAtLeast(currentSum + firstLenSum[0][i - 1].coerceAtLeast(onRight))
+            i++
+            j++
+        }
+        return maxSum
+    }
+
+    private fun getFirstLenSums(nums: IntArray, windowSize: Int): Array<IntArray> {
+        // sum[0] - maximum from left to right, sum[1] - max from right to left.
+        val sum = Array(2) { IntArray(nums.size) }
+        var currentLeftSum = 0
+        var currentRightSum = 0
+        run {
+            var i = 0
+            var j = nums.size - 1
+            while (i < windowSize) {
+                currentLeftSum += nums[i]
+                currentRightSum += nums[j]
+                i++
+                j--
+            }
+        }
+        sum[0][windowSize - 1] = currentLeftSum
+        sum[1][nums.size - windowSize] = currentRightSum
+        var i = windowSize
+        var j = nums.size - windowSize - 1
+        while (i < nums.size) {
+            currentLeftSum = currentLeftSum - nums[i - windowSize] + nums[i]
+            currentRightSum = currentRightSum - nums[j + windowSize] + nums[j]
+            sum[0][i] = sum[0][i - 1].coerceAtLeast(currentLeftSum)
+            sum[1][j] = sum[1][j + 1].coerceAtLeast(currentRightSum)
+            i++
+            j--
+        }
+        return sum
+    }
+}

src/main/kotlin/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 [0,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/kotlin/g1001_1100/s1032_stream_of_characters/StreamChecker.kt

@@ -0,0 +1,53 @@
+package g1001_1100.s1032_stream_of_characters
+
+// #Hard #Array #String #Design #Trie #Data_Stream
+// #2023_05_24_Time_733_ms_(100.00%)_Space_158.5_MB_(50.00%)
+
+class StreamChecker(words: Array<String>) {
+    internal class Node {
+        var child: Array<Node?> = arrayOfNulls(26)
+        var isEnd = false
+    }
+
+    private val sb: StringBuilder = StringBuilder()
+    private val root: Node = Node()
+    fun insert(s: String) {
+        var curr: Node? = root
+        for (i in s.length - 1 downTo 0) {
+            val c = s[i]
+            if (curr!!.child[c.code - 'a'.code] == null) {
+                curr.child[c.code - 'a'.code] = Node()
+            }
+            curr = curr.child[c.code - 'a'.code]
+        }
+        curr!!.isEnd = true
+    }
+
+    init {
+        for (s in words) {
+            insert(s)
+        }
+    }
+
+    fun query(letter: Char): Boolean {
+        sb.append(letter)
+        var curr: Node? = root
+        for (i in sb.length - 1 downTo 0) {
+            val c = sb[i]
+            if (curr!!.child[c.code - 'a'.code] == null) {
+                return false
+            }
+            if (curr.child[c.code - 'a'.code]!!.isEnd) {
+                return true
+            }
+            curr = curr.child[c.code - 'a'.code]
+        }
+        return false
+    }
+}
+
+/*
+ * Your StreamChecker object will be instantiated and called as such:
+ * var obj = StreamChecker(words)
+ * var param_1 = obj.query(letter)
+ */

src/main/kotlin/g1001_1100/s1032_stream_of_characters/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 [0,3,8] with length 3.
+
+**Constraints:**
+
+*   `1 <= firstLen, secondLen <= 1000`
+*   `2 <= firstLen + secondLen <= 1000`
+*   `firstLen + secondLen <= nums.length <= 1000`
+*   `0 <= nums[i] <= 1000`