Added tasks 659, 661, 662, 664

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
+| 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
+| 0659 |[Split Array into Consecutive Subsequences](src/main/kotlin/g0601_0700/s0659_split_array_into_consecutive_subsequences/Solution.kt)| Medium | Array, Hash_Table, Greedy, Heap_Priority_Queue | 352 | 100.00
 | 0658 |[Find K Closest Elements](src/main/kotlin/g0601_0700/s0658_find_k_closest_elements/Solution.kt)| Medium | Array, Sorting, Binary_Search, Two_Pointers, Heap_Priority_Queue, Binary_Search_II_Day_2 | 375 | 95.16
 | 0657 |[Robot Return to Origin](src/main/kotlin/g0601_0700/s0657_robot_return_to_origin/Solution.kt)| Easy | String, Simulation | 186 | 100.00
 | 0655 |[Print Binary Tree](src/main/kotlin/g0601_0700/s0655_print_binary_tree/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 176 | 100.00

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

@@ -0,0 +1,31 @@
+package g0601_0700.s0659_split_array_into_consecutive_subsequences
+
+// #Medium #Array #Hash_Table #Greedy #Heap_Priority_Queue
+// #2023_02_14_Time_352_ms_(100.00%)_Space_38.5_MB_(100.00%)
+
+class Solution {
+    fun isPossible(nums: IntArray): Boolean {
+        val element = IntArray(2001)
+        for (num in nums) {
+            element[num + 1000] += 1
+        }
+        for (i in element.indices) {
+            while (element[i] > 0) {
+                var length = 1
+                while (i + length < element.size &&
+                    element[i + length] >= element[i + length - 1]
+                ) {
+                    length += 1
+                }
+                if (length < 3) {
+                    return false
+                } else {
+                    for (j in i until i + length) {
+                        element[j] -= 1
+                    }
+                }
+            }
+        }
+        return true
+    }
+}

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

@@ -0,0 +1,52 @@
+659\. Split Array into Consecutive Subsequences
+
+Medium
+
+You are given an integer array `nums` that is **sorted in non-decreasing order**.
+
+Determine if it is possible to split `nums` into **one or more subsequences** such that **both** of the following conditions are true:
+
+*   Each subsequence is a **consecutive increasing sequence** (i.e. each integer is **exactly one** more than the previous integer).
+*   All subsequences have a length of `3` **or more**.
+
+Return `true` _if you can split_ `nums` _according to the above conditions, or_ `false` _otherwise_.
+
+A **subsequence** of an array is a new array that is formed from the original array by deleting some (can be none) of the elements without disturbing the relative positions of the remaining elements. (i.e., `[1,3,5]` is a subsequence of <code>[<ins>1</ins>,2,<ins>3</ins>,4,<ins>5</ins>]</code> while `[1,3,2]` is not).
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,3,4,5]
+
+**Output:** true
+
+**Explanation:** nums can be split into the following subsequences: 
+
+[**<ins>1</ins>**,**<ins>2</ins>**,**<ins>3</ins>**,3,4,5] --> 1, 2, 3 
+
+    [1,2,3,**<ins>3</ins>**,**<ins>4</ins>**,**<ins>5</ins>**] --> 3, 4, 5
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,3,4,4,5,5]
+
+**Output:** true
+
+**Explanation:** nums can be split into the following subsequences: 
+
+[**<ins>1</ins>**,**<ins>2</ins>**,**<ins>3</ins>**,3,**<ins>4</ins>**,4,**<ins>5</ins>**,5] --> 1, 2, 3, 4, 5 
+
+[1,2,3,**<ins>3</ins>**,4,**<ins>4</ins>**,5,**<ins>5</ins>**] --> 3, 4, 5
+
+**Example 3:**
+
+**Input:** nums = [1,2,3,4,4,5]
+
+**Output:** false
+
+**Explanation:** It is impossible to split nums into consecutive increasing subsequences of length 3 or more.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   `-1000 <= nums[i] <= 1000`
+*   `nums` is sorted in **non-decreasing** order.

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

@@ -0,0 +1,58 @@
+package g0601_0700.s0661_image_smoother
+
+// #Easy #Array #Matrix #2023_02_14_Time_352_ms_(100.00%)_Space_44.4_MB_(33.33%)
+
+class Solution {
+    fun imageSmoother(matrix: Array<IntArray>?): Array<IntArray>? {
+        if (matrix.isNullOrEmpty()) {
+            return matrix
+        }
+        val m = matrix.size
+        val n = matrix[0].size
+        val result = Array(m) { IntArray(n) }
+        for (i in 0 until m) {
+            for (j in 0 until n) {
+                bfs(matrix, i, j, result, m, n)
+            }
+        }
+        return result
+    }
+
+    private fun bfs(matrix: Array<IntArray>, i: Int, j: Int, result: Array<IntArray>, m: Int, n: Int) {
+        var sum = matrix[i][j]
+        var denominator = 1
+        if (j + 1 < n) {
+            sum += matrix[i][j + 1]
+            denominator++
+        }
+        if (i + 1 < m && j + 1 < n) {
+            sum += matrix[i + 1][j + 1]
+            denominator++
+        }
+        if (i + 1 < m) {
+            sum += matrix[i + 1][j]
+            denominator++
+        }
+        if (i + 1 < m && j - 1 >= 0) {
+            sum += matrix[i + 1][j - 1]
+            denominator++
+        }
+        if (j - 1 >= 0) {
+            sum += matrix[i][j - 1]
+            denominator++
+        }
+        if (i - 1 >= 0 && j - 1 >= 0) {
+            sum += matrix[i - 1][j - 1]
+            denominator++
+        }
+        if (i - 1 >= 0) {
+            sum += matrix[i - 1][j]
+            denominator++
+        }
+        if (i - 1 >= 0 && j + 1 < n) {
+            sum += matrix[i - 1][j + 1]
+            denominator++
+        }
+        result[i][j] = sum / denominator
+    }
+}

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

@@ -0,0 +1,48 @@
+661\. Image Smoother
+
+Easy
+
+An **image smoother** is a filter of the size `3 x 3` that can be applied to each cell of an image by rounding down the average of the cell and the eight surrounding cells (i.e., the average of the nine cells in the blue smoother). If one or more of the surrounding cells of a cell is not present, we do not consider it in the average (i.e., the average of the four cells in the red smoother).
+
+![](https://assets.leetcode.com/uploads/2021/05/03/smoother-grid.jpg)
+
+Given an `m x n` integer matrix `img` representing the grayscale of an image, return _the image after applying the smoother on each cell of it_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/05/03/smooth-grid.jpg)
+
+**Input:** img = [[1,1,1],[1,0,1],[1,1,1]]
+
+**Output:** [[0,0,0],[0,0,0],[0,0,0]]
+
+**Explanation:**
+
+For the points (0,0), (0,2), (2,0), (2,2): floor(3/4) = floor(0.75) = 0
+
+For the points (0,1), (1,0), (1,2), (2,1): floor(5/6) = floor(0.83333333) = 0
+
+For the point (1,1): floor(8/9) = floor(0.88888889) = 0
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/05/03/smooth2-grid.jpg)
+
+**Input:** img = [[100,200,100],[200,50,200],[100,200,100]]
+
+**Output:** [[137,141,137],[141,138,141],[137,141,137]]
+
+**Explanation:**
+
+For the points (0,0), (0,2), (2,0), (2,2): floor((100+200+200+50)/4) = floor(137.5) = 137
+
+For the points (0,1), (1,0), (1,2), (2,1): floor((200+200+50+200+100+100)/6) = floor(141.666667) = 141
+
+For the point (1,1): floor((50+200+200+200+200+100+100+100+100)/9) = floor(138.888889) = 138
+
+**Constraints:**
+
+*   `m == img.length`
+*   `n == img[i].length`
+*   `1 <= m, n <= 200`
+*   `0 <= img[i][j] <= 255`

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

@@ -0,0 +1,59 @@
+package g0601_0700.s0662_maximum_width_of_binary_tree
+
+// #Medium #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree
+// #2023_02_14_Time_189_ms_(75.00%)_Space_35.6_MB_(100.00%)
+
+import com_github_leetcode.TreeNode
+import java.util.LinkedList
+import java.util.Objects
+import java.util.Queue
+
+/*
+ * 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 {
+    internal class Pair(node: TreeNode, idx: Int) {
+        var node: TreeNode
+        var idx: Int
+
+        init {
+            this.node = node
+            this.idx = idx
+        }
+    }
+
+    fun widthOfBinaryTree(root: TreeNode): Int {
+        val q: Queue<Pair> = LinkedList()
+        q.add(Pair(root, 0))
+        var res = 1
+        while (!q.isEmpty()) {
+            val qSize = q.size
+            var lastIdx = 0
+            var firstIdx = 0
+            for (i in 0 until qSize) {
+                val temp = q.poll()
+                if (i == 0) {
+                    firstIdx = temp.idx
+                }
+                if (i == qSize - 1) {
+                    lastIdx = Objects.requireNonNull(temp).idx
+                }
+                if (Objects.requireNonNull(temp).node.left != null) {
+                    q.add(Pair(temp.node.left!!, 2 * temp.idx + 1))
+                }
+                if (temp.node.right != null) {
+                    q.add(Pair(temp.node.right!!, 2 * temp.idx + 2))
+                }
+            }
+            res = (lastIdx - firstIdx + 1).coerceAtLeast(res)
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,46 @@
+662\. Maximum Width of Binary Tree
+
+Medium
+
+Given the `root` of a binary tree, return _the **maximum width** of the given tree_.
+
+The **maximum width** of a tree is the maximum **width** among all levels.
+
+The **width** of one level is defined as the length between the end-nodes (the leftmost and rightmost non-null nodes), where the null nodes between the end-nodes that would be present in a complete binary tree extending down to that level are also counted into the length calculation.
+
+It is **guaranteed** that the answer will in the range of a **32-bit** signed integer.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/05/03/width1-tree.jpg)
+
+**Input:** root = [1,3,2,5,3,null,9]
+
+**Output:** 4
+
+**Explanation:** The maximum width exists in the third level with length 4 (5,3,null,9).
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/03/14/maximum-width-of-binary-tree-v3.jpg)
+
+**Input:** root = [1,3,2,5,null,null,9,6,null,7]
+
+**Output:** 7
+
+**Explanation:** The maximum width exists in the fourth level with length 7 (6,null,null,null,null,null,7).
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/05/03/width3-tree.jpg)
+
+**Input:** root = [1,3,2,5]
+
+**Output:** 2
+
+**Explanation:** The maximum width exists in the second level with length 2 (3,2).
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 3000]`.
+*   `-100 <= Node.val <= 100`

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

@@ -0,0 +1,29 @@
+package g0601_0700.s0664_strange_printer
+
+// #Hard #String #Dynamic_Programming #2023_02_14_Time_196_ms_(100.00%)_Space_35.3_MB_(100.00%)
+
+class Solution {
+    fun strangePrinter(s: String): Int {
+        if (s.isEmpty()) {
+            return 0
+        }
+        val dp = Array(s.length) { IntArray(s.length) }
+        for (i in s.length - 1 downTo 0) {
+            for (j in i until s.length) {
+                if (i == j) {
+                    dp[i][j] = 1
+                } else if (s[i] == s[i + 1]) {
+                    dp[i][j] = dp[i + 1][j]
+                } else {
+                    dp[i][j] = dp[i + 1][j] + 1
+                    for (k in i + 1..j) {
+                        if (s[k] == s[i]) {
+                            dp[i][j] = dp[i][j].coerceAtMost(dp[i + 1][k - 1] + dp[k][j])
+                        }
+                    }
+                }
+            }
+        }
+        return dp[0][s.length - 1]
+    }
+}

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

@@ -0,0 +1,31 @@
+664\. Strange Printer
+
+Hard
+
+There is a strange printer with the following two special properties:
+
+*   The printer can only print a sequence of **the same character** each time.
+*   At each turn, the printer can print new characters starting from and ending at any place and will cover the original existing characters.
+
+Given a string `s`, return _the minimum number of turns the printer needed to print it_.
+
+**Example 1:**
+
+**Input:** s = "aaabbb"
+
+**Output:** 2
+
+**Explanation:** Print "aaa" first and then print "bbb".
+
+**Example 2:**
+
+**Input:** s = "aba"
+
+**Output:** 2
+
+**Explanation:** Print "aaa" first and then print "b" from the second place of the string, which will cover the existing character 'a'.
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s` consists of lowercase English letters.

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

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