Added tasks 665, 667, 668, 669

Author: ThanhNIT

README.md

@@ -1675,6 +1675,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
 | 0763 |[Partition Labels](src/main/kotlin/g0701_0800/s0763_partition_labels/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String | 235 | 84.75
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
+| 0669 |[Trim a Binary Search Tree](src/main/kotlin/g0601_0700/s0669_trim_a_binary_search_tree/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 195 | 100.00
+| 0668 |[Kth Smallest Number in Multiplication Table](src/main/kotlin/g0601_0700/s0668_kth_smallest_number_in_multiplication_table/Solution.kt)| Hard | Math, Binary_Search | 151 | 100.00
+| 0667 |[Beautiful Arrangement II](src/main/kotlin/g0601_0700/s0667_beautiful_arrangement_ii/Solution.kt)| Medium | Array, Math | 175 | 100.00
+| 0665 |[Non-decreasing Array](src/main/kotlin/g0601_0700/s0665_non_decreasing_array/Solution.kt)| Medium | Array | 256 | 85.71
 | 0664 |[Strange Printer](src/main/kotlin/g0601_0700/s0664_strange_printer/Solution.kt)| Hard | String, Dynamic_Programming | 196 | 100.00
 | 0662 |[Maximum Width of Binary Tree](src/main/kotlin/g0601_0700/s0662_maximum_width_of_binary_tree/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 189 | 75.00
 | 0661 |[Image Smoother](src/main/kotlin/g0601_0700/s0661_image_smoother/Solution.kt)| Easy | Array, Matrix | 352 | 100.00

src/main/kotlin/g0601_0700/s0665_non_decreasing_array/Solution.kt

@@ -0,0 +1,37 @@
+package g0601_0700.s0665_non_decreasing_array
+
+// #Medium #Array #2023_02_14_Time_256_ms_(85.71%)_Space_39.8_MB_(28.57%)
+
+class Solution {
+    fun checkPossibility(nums: IntArray): Boolean {
+        val n = nums.size
+        if (n <= 2) {
+            return true
+        }
+
+        var isModified = false
+        for (i in 0..(n - 2)) {
+            if (nums[i] <= nums[i + 1]) {
+                continue
+            }
+            if (isModified) {
+                return false
+            }
+
+            when {
+                i == 0 || nums[i - 1] <= nums[i + 1] -> {
+                    nums[i] = nums[i + 1]
+                    isModified = true
+                }
+                i == n - 2 || nums[i] <= nums[i + 2] -> {
+                    nums[i + 1] = nums[i]
+                    isModified = true
+                }
+                else -> {
+                    return false
+                }
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g0601_0700/s0665_non_decreasing_array/readme.md

@@ -0,0 +1,29 @@
+665\. Non-decreasing Array
+
+Medium
+
+Given an array `nums` with `n` integers, your task is to check if it could become non-decreasing by modifying **at most one element**.
+
+We define an array is non-decreasing if `nums[i] <= nums[i + 1]` holds for every `i` (**0-based**) such that (`0 <= i <= n - 2`).
+
+**Example 1:**
+
+**Input:** nums = [4,2,3]
+
+**Output:** true
+
+**Explanation:** You could modify the first 4 to 1 to get a non-decreasing array.
+
+**Example 2:**
+
+**Input:** nums = [4,2,1]
+
+**Output:** false
+
+**Explanation:** You cannot get a non-decreasing array by modifying at most one element.
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 10<sup>4</sup></code>
+*   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>

src/main/kotlin/g0601_0700/s0667_beautiful_arrangement_ii/Solution.kt

@@ -0,0 +1,19 @@
+package g0601_0700.s0667_beautiful_arrangement_ii
+
+// #Medium #Array #Math #2023_02_14_Time_175_ms_(100.00%)_Space_36.1_MB_(100.00%)
+
+class Solution {
+    fun constructArray(n: Int, k: Int): IntArray {
+        var k = k
+        val res = IntArray(n)
+        var left = 1
+        var right = n
+        for (i in 0 until n) {
+            res[i] = if (k % 2 == 0) left++ else right--
+            if (k > 1) {
+                k--
+            }
+        }
+        return res
+    }
+}

src/main/kotlin/g0601_0700/s0667_beautiful_arrangement_ii/readme.md

@@ -0,0 +1,25 @@
+667\. Beautiful Arrangement II
+
+Medium
+
+Given two integers `n` and `k`, construct a list `answer` that contains `n` different positive integers ranging from `1` to `n` and obeys the following requirement:
+
+*   Suppose this list is <code>answer = [a<sub>1</sub>, a<sub>2</sub>, a<sub>3</sub>, ... , a<sub>n</sub>]</code>, then the list <code>[|a<sub>1</sub> - a<sub>2</sub>|, |a<sub>2</sub> - a<sub>3</sub>|, |a<sub>3</sub> - a<sub>4</sub>|, ... , |a<sub>n-1</sub> - a<sub>n</sub>|]</code> has exactly `k` distinct integers.
+
+Return _the list_ `answer`. If there multiple valid answers, return **any of them**.
+
+**Example 1:**
+
+**Input:** n = 3, k = 1
+
+**Output:** [1,2,3] Explanation: The [1,2,3] has three different positive integers ranging from 1 to 3, and the [1,1] has exactly 1 distinct integer: 1
+
+**Example 2:**
+
+**Input:** n = 3, k = 2
+
+**Output:** [1,3,2] Explanation: The [1,3,2] has three different positive integers ranging from 1 to 3, and the [2,1] has exactly 2 distinct integers: 1 and 2.
+
+**Constraints:**
+
+*   <code>1 <= k < n <= 10<sup>4</sup></code>

src/main/kotlin/g0601_0700/s0668_kth_smallest_number_in_multiplication_table/Solution.kt

@@ -0,0 +1,31 @@
+package g0601_0700.s0668_kth_smallest_number_in_multiplication_table
+
+// #Hard #Math #Binary_Search #2023_02_14_Time_151_ms_(100.00%)_Space_33_MB_(50.00%)
+
+class Solution {
+    fun findKthNumber(m: Int, n: Int, k: Int): Int {
+        var lo = 1
+        var hi = m * n
+        while (lo < hi) {
+            val mid = lo + (hi - lo) / 2
+            var col = n
+            var row = 1
+            var count = 0
+            while (row <= m && col >= 1) {
+                val `val` = row * col
+                if (`val` > mid) {
+                    col--
+                } else {
+                    count += col
+                    row++
+                }
+            }
+            if (count < k) {
+                lo = mid + 1
+            } else {
+                hi = mid
+            }
+        }
+        return lo
+    }
+}

src/main/kotlin/g0601_0700/s0668_kth_smallest_number_in_multiplication_table/readme.md

@@ -0,0 +1,32 @@
+668\. Kth Smallest Number in Multiplication Table
+
+Hard
+
+Nearly everyone has used the [Multiplication Table](https://en.wikipedia.org/wiki/Multiplication_table). The multiplication table of size `m x n` is an integer matrix `mat` where `mat[i][j] == i * j` (**1-indexed**).
+
+Given three integers `m`, `n`, and `k`, return _the_ <code>k<sup>th</sup></code> _smallest element in the_ `m x n` _multiplication table_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/05/02/multtable1-grid.jpg)
+
+**Input:** m = 3, n = 3, k = 5
+
+**Output:** 3
+
+**Explanation:** The 5<sup>th</sup> smallest number is 3.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/05/02/multtable2-grid.jpg)
+
+**Input:** m = 2, n = 3, k = 6
+
+**Output:** 6
+
+**Explanation:** The 6<sup>th</sup> smallest number is 6.
+
+**Constraints:**
+
+*   <code>1 <= m, n <= 3 * 10<sup>4</sup></code>
+*   `1 <= k <= m * n`

src/main/kotlin/g0601_0700/s0669_trim_a_binary_search_tree/Solution.kt

@@ -0,0 +1,33 @@
+package g0601_0700.s0669_trim_a_binary_search_tree
+
+// #Medium #Depth_First_Search #Tree #Binary_Tree #Binary_Search_Tree
+// #2023_02_14_Time_195_ms_(100.00%)_Space_36.3_MB_(100.00%)
+
+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 {
+    fun trimBST(root: TreeNode?, l: Int, r: Int): TreeNode? {
+        if (root == null) {
+            return root
+        }
+        if (root.`val` > r) {
+            return trimBST(root.left, l, r)
+        }
+        if (root.`val` < l) {
+            return trimBST(root.right, l, r)
+        }
+        root.left = trimBST(root.left, l, r)
+        root.right = trimBST(root.right, l, r)
+        return root
+    }
+}

src/main/kotlin/g0601_0700/s0669_trim_a_binary_search_tree/readme.md

@@ -0,0 +1,31 @@
+669\. Trim a Binary Search Tree
+
+Medium
+
+Given the `root` of a binary search tree and the lowest and highest boundaries as `low` and `high`, trim the tree so that all its elements lies in `[low, high]`. Trimming the tree should **not** change the relative structure of the elements that will remain in the tree (i.e., any node's descendant should remain a descendant). It can be proven that there is a **unique answer**.
+
+Return _the root of the trimmed binary search tree_. Note that the root may change depending on the given bounds.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/09/trim1.jpg)
+
+**Input:** root = [1,0,2], low = 1, high = 2
+
+**Output:** [1,null,2]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/09/09/trim2.jpg)
+
+**Input:** root = [3,0,4,null,2,null,null,1], low = 1, high = 3
+
+**Output:** [3,2,null,1]
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.
+*   <code>0 <= Node.val <= 10<sup>4</sup></code>
+*   The value of each node in the tree is **unique**.
+*   `root` is guaranteed to be a valid binary search tree.
+*   <code>0 <= low <= high <= 10<sup>4</sup></code>

src/test/kotlin/g0601_0700/s0665_non_decreasing_array/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0601_0700.s0665_non_decreasing_array
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun checkPossibility() {
+        assertThat(Solution().checkPossibility(intArrayOf(4, 2, 3)), equalTo(true))
+    }
+
+    @Test
+    fun checkPossibility2() {
+        assertThat(Solution().checkPossibility(intArrayOf(4, 2, 1)), equalTo(false))
+    }
+}