Added tasks 93, 95, 97.

Author: ThanhNIT

README.md

@@ -1531,8 +1531,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 0102 |[Binary Tree Level Order Traversal](src/main/kotlin/g0101_0200/s0102_binary_tree_level_order_traversal/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_I_Day_11_Tree, Level_1_Day_6_Tree, Udemy_Tree_Stack_Queue | 355 | 29.37
 | 0101 |[Symmetric Tree](src/main/kotlin/g0101_0200/s0101_symmetric_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_I_Day_11_Tree, Level_2_Day_15_Tree | 290 | 26.98
 | 0098 |[Validate Binary Search Tree](src/main/kotlin/g0001_0100/s0098_validate_binary_search_tree/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_I_Day_14_Tree, Level_1_Day_8_Binary_Search_Tree, Udemy_Tree_Stack_Queue | 330 | 41.38
+| 0097 |[Interleaving String](src/main/kotlin/g0001_0100/s0097_interleaving_string/Solution.kt)| Medium | String, Dynamic_Programming | 240 | 57.50
 | 0096 |[Unique Binary Search Trees](src/main/kotlin/g0001_0100/s0096_unique_binary_search_trees/Solution.kt)| Medium | Top_100_Liked_Questions, Dynamic_Programming, Math, Tree, Binary_Tree, Binary_Search_Tree, Dynamic_Programming_I_Day_11 | 237 | 26.76
+| 0095 |[Unique Binary Search Trees II](src/main/kotlin/g0001_0100/s0095_unique_binary_search_trees_ii/Solution.kt)| Medium | Dynamic_Programming, Tree, Binary_Tree, Backtracking, Binary_Search_Tree | 360 | 41.38
 | 0094 |[Largest Rectangle in Histogram](src/main/kotlin/g0001_0100/s0094_binary_tree_inorder_traversal/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Stack, Data_Structure_I_Day_10_Tree, Udemy_Tree_Stack_Queue | 283 | 17.97
+| 0093 |[Restore IP Addresses](src/main/kotlin/g0001_0100/s0093_restore_ip_addresses/Solution.kt)| Medium | String, Backtracking | 304 | 73.33
 | 0092 |[Reverse Linked List II](src/main/kotlin/g0001_0100/s0092_reverse_linked_list_ii/Solution.kt)| Medium | Linked_List | 191 | 82.35
 | 0091 |[Decode Ways](src/main/kotlin/g0001_0100/s0091_decode_ways/Solution.kt)| Medium | Top_Interview_Questions, String, Dynamic_Programming, Algorithm_II_Day_15_Dynamic_Programming, Dynamic_Programming_I_Day_10 | 327 | 17.68
 | 0090 |[Subsets II](src/main/kotlin/g0001_0100/s0090_subsets_ii/Solution.kt)| Medium | Array, Bit_Manipulation, Backtracking, Algorithm_II_Day_9_Recursion_Backtracking | 366 | 58.09

src/main/kotlin/g0001_0100/s0093_restore_ip_addresses/Solution.kt

@@ -0,0 +1,39 @@
+package g0001_0100.s0093_restore_ip_addresses
+
+// #Medium #String #Backtracking #2022_09_26_Time_304_ms_(73.33%)_Space_35.8_MB_(93.33%)
+
+class Solution() {
+    fun restoreIpAddresses(s: String): List<String> {
+        val results: MutableList<String> = ArrayList()
+        step(s, 0, IntArray(4), 0, results)
+        return results
+    }
+
+    fun step(s: String, pos: Int, octets: IntArray, count: Int, results: MutableList<String>) {
+        if (count == 4 && pos == s.length) {
+            results.add(
+                octets[0].toString() + '.' +
+                    octets[1] +
+                    '.' +
+                    octets[2] +
+                    '.' +
+                    octets[3]
+            )
+        } else if (count < 4 && pos < 12) {
+            var octet = 0
+            for (i in 0..2) {
+                if (pos + i < s.length) {
+                    val digit = s[pos + i] - '0'
+                    octet = octet * 10 + digit
+                    if (octet < 256) {
+                        octets[count] = octet
+                        step(s, pos + i + 1, octets, count + 1, results)
+                    }
+                    if (i == 0 && digit == 0) {
+                        break
+                    }
+                }
+            }
+        }
+    }
+}

src/main/kotlin/g0001_0100/s0093_restore_ip_addresses/readme.md

@@ -0,0 +1,32 @@
+93\. Restore IP Addresses
+
+Medium
+
+A **valid IP address** consists of exactly four integers separated by single dots. Each integer is between `0` and `255` (**inclusive**) and cannot have leading zeros.
+
+*   For example, `"0.1.2.201"` and `"192.168.1.1"` are **valid** IP addresses, but `"0.011.255.245"`, `"192.168.1.312"` and `"192.168@1.1"` are **invalid** IP addresses.
+
+Given a string `s` containing only digits, return _all possible valid IP addresses that can be formed by inserting dots into_ `s`. You are **not** allowed to reorder or remove any digits in `s`. You may return the valid IP addresses in **any** order.
+
+**Example 1:**
+
+**Input:** s = "25525511135"
+
+**Output:** ["255.255.11.135","255.255.111.35"]
+
+**Example 2:**
+
+**Input:** s = "0000"
+
+**Output:** ["0.0.0.0"]
+
+**Example 3:**
+
+**Input:** s = "101023"
+
+**Output:** ["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]
+
+**Constraints:**
+
+*   `1 <= s.length <= 20`
+*   `s` consists of digits only.

src/main/kotlin/g0001_0100/s0095_unique_binary_search_trees_ii/Solution.kt

@@ -0,0 +1,58 @@
+package g0001_0100.s0095_unique_binary_search_trees_ii
+
+// #Medium #Dynamic_Programming #Tree #Binary_Tree #Backtracking #Binary_Search_Tree
+// #2022_09_26_Time_360_ms_(41.38%)_Space_42.4_MB_(72.41%)
+
+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 generateTrees(n: Int): List<TreeNode?> {
+        var result: MutableList<TreeNode?> = ArrayList<TreeNode?>()
+        result.add(TreeNode(1))
+        for (i in 2..n) {
+            val nresult: MutableList<TreeNode?> = ArrayList<TreeNode?>()
+            for (r in result) {
+                var node = TreeNode(i, r, null)
+                nresult.add(node)
+                var previous: TreeNode? = r
+                while (previous != null) {
+                    node = TreeNode(i)
+                    val cr: TreeNode? = copy(r)
+                    insert(cr, node, previous)
+                    previous = node.left
+                    nresult.add(cr)
+                }
+            }
+            result = nresult
+        }
+        return result
+    }
+
+    private fun insert(dest: TreeNode?, n: TreeNode, from: TreeNode) {
+        if (dest != null && dest.`val` === from.`val`) {
+            val h: TreeNode? = dest.right
+            dest.right = n
+            n.left = h
+            return
+        }
+        if (dest != null) {
+            insert(dest.right, n, from)
+        }
+    }
+
+    private fun copy(n: TreeNode?): TreeNode? {
+        return if (n == null) {
+            null
+        } else TreeNode(n.`val`, copy(n.left), copy(n.right))
+    }
+}

src/main/kotlin/g0001_0100/s0095_unique_binary_search_trees_ii/readme.md

@@ -0,0 +1,23 @@
+95\. Unique Binary Search Trees II
+
+Medium
+
+Given an integer `n`, return _all the structurally unique **BST'**s (binary search trees), which has exactly_ `n` _nodes of unique values from_ `1` _to_ `n`. Return the answer in **any order**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/18/uniquebstn3.jpg)
+
+**Input:** n = 3
+
+**Output:** [[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** [[1]]
+
+**Constraints:**
+
+*   `1 <= n <= 8`

src/main/kotlin/g0001_0100/s0097_interleaving_string/Solution.kt

@@ -0,0 +1,39 @@
+package g0001_0100.s0097_interleaving_string
+
+// #Medium #String #Dynamic_Programming #2022_09_26_Time_240_ms_(57.50%)_Space_35.1_MB_(57.50%)
+
+class Solution {
+    fun isInterleave(s1: String, s2: String, s3: String): Boolean {
+        if (s3.length != s1.length + s2.length) {
+            return false
+        }
+        val cache = Array(s1.length + 1) { arrayOfNulls<Boolean>(s2.length + 1) }
+        return isInterleave(s1, s2, s3, 0, 0, 0, cache)
+    }
+
+    fun isInterleave(
+        s1: String,
+        s2: String,
+        s3: String,
+        i1: Int,
+        i2: Int,
+        i3: Int,
+        cache: Array<Array<Boolean?>>
+    ): Boolean {
+        if (cache[i1][i2] != null) {
+            return cache[i1][i2]!!
+        }
+        if (i1 == s1.length && i2 == s2.length && i3 == s3.length) {
+            return true
+        }
+        var result = false
+        if (i1 < s1.length && s1[i1] == s3[i3]) {
+            result = isInterleave(s1, s2, s3, i1 + 1, i2, i3 + 1, cache)
+        }
+        if (i2 < s2.length && s2[i2] == s3[i3]) {
+            result = result || isInterleave(s1, s2, s3, i1, i2 + 1, i3 + 1, cache)
+        }
+        cache[i1][i2] = result
+        return result
+    }
+}

src/main/kotlin/g0001_0100/s0097_interleaving_string/readme.md

@@ -0,0 +1,46 @@
+97\. Interleaving String
+
+Medium
+
+Given strings `s1`, `s2`, and `s3`, find whether `s3` is formed by an **interleaving** of `s1` and `s2`.
+
+An **interleaving** of two strings `s` and `t` is a configuration where `s` and `t` are divided into `n` and `m` **non-empty** substrings respectively, such that:
+
+*   <code>s = s<sub>1</sub> + s<sub>2</sub> + ... + s<sub>n</sub></code>
+*   <code>t = t<sub>1</sub> + t<sub>2</sub> + ... + t<sub>m</sub></code>
+*   `|n - m| <= 1`
+*   The **interleaving** is <code>s<sub>1</sub> + t<sub>1</sub> + s<sub>2</sub> + t<sub>2</sub> + s<sub>3</sub> + t<sub>3</sub> + ...</code> or <code>t<sub>1</sub> + s<sub>1</sub> + t<sub>2</sub> + s<sub>2</sub> + t<sub>3</sub> + s<sub>3</sub> + ...</code>
+
+**Note:** `a + b` is the concatenation of strings `a` and `b`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/02/interleave.jpg)
+
+**Input:** s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
+
+**Output:** true
+
+**Explanation:** One way to obtain s3 is: Split s1 into s1 = "aa" + "bc" + "c", and s2 into s2 = "dbbc" + "a". Interleaving the two splits, we get "aa" + "dbbc" + "bc" + "a" + "c" = "aadbbcbcac". Since s3 can be obtained by interleaving s1 and s2, we return true.
+
+**Example 2:**
+
+**Input:** s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
+
+**Output:** false
+
+**Explanation:** Notice how it is impossible to interleave s2 with any other string to obtain s3.
+
+**Example 3:**
+
+**Input:** s1 = "", s2 = "", s3 = ""
+
+**Output:** true
+
+**Constraints:**
+
+*   `0 <= s1.length, s2.length <= 100`
+*   `0 <= s3.length <= 200`
+*   `s1`, `s2`, and `s3` consist of lowercase English letters.
+
+**Follow up:** Could you solve it using only `O(s2.length)` additional memory space?

src/test/kotlin/g0001_0100/s0093_restore_ip_addresses/SolutionTest.kt

@@ -0,0 +1,28 @@
+package g0001_0100.s0093_restore_ip_addresses
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun restoreIpAddresses() {
+        assertThat(
+            Solution().restoreIpAddresses("25525511135").toString(),
+            equalTo("[255.255.11.135, 255.255.111.35]")
+        )
+    }
+
+    @Test
+    fun restoreIpAddresses2() {
+        assertThat(Solution().restoreIpAddresses("0000").toString(), equalTo("[0.0.0.0]"))
+    }
+
+    @Test
+    fun restoreIpAddresses3() {
+        assertThat(
+            Solution().restoreIpAddresses("101023").toString(),
+            equalTo("[1.0.10.23, 1.0.102.3, 10.1.0.23, 10.10.2.3, 101.0.2.3]")
+        )
+    }
+}

src/test/kotlin/g0001_0100/s0095_unique_binary_search_trees_ii/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0001_0100.s0095_unique_binary_search_trees_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun generateTrees() {
+        assertThat(
+            Solution().generateTrees(3).toString(),
+            equalTo(
+                "[3,2,1,null,null, 2,1,3, 3,1,null,2,null, 1,null,3,2,null, 1,null,2,null,3]"
+            )
+        )
+    }
+
+    @Test
+    fun generateTrees2() {
+        assertThat(Solution().generateTrees(1).toString(), equalTo("[1]"))
+    }
+}

src/test/kotlin/g0001_0100/s0097_interleaving_string/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0001_0100.s0097_interleaving_string
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isInterleave() {
+        assertThat(Solution().isInterleave("aabcc", "dbbca", "aadbbcbcac"), equalTo(true))
+    }
+
+    @Test
+    fun isInterleave2() {
+        assertThat(Solution().isInterleave("aabcc", "dbbca", "aadbbbaccc"), equalTo(false))
+    }
+
+    @Test
+    fun isInterleave3() {
+        assertThat(Solution().isInterleave("", "", ""), equalTo(true))
+    }
+}