Added tasks 940, 941, 942, 943

Author: ThanhNIT

README.md

@@ -1733,6 +1733,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.12'
 |------|----------------|-------------|-------------|----------|---------
 | 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
 | 0994 |[Rotting Oranges](src/main/kotlin/g0901_1000/s0994_rotting_oranges/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix, Algorithm_I_Day_9_Breadth_First_Search_Depth_First_Search, Level_2_Day_10_Graph/BFS/DFS | 308 | 57.93
+| 0943 |[Find the Shortest Superstring](src/main/kotlin/g0901_1000/s0943_find_the_shortest_superstring/Solution.kt)| Hard | Array, String, Dynamic_Programming, Bit_Manipulation, Bitmask | 1290 | 100.00
+| 0942 |[DI String Match](src/main/kotlin/g0901_1000/s0942_di_string_match/Solution.kt)| Easy | Array, String, Math, Greedy, Two_Pointers | 202 | 80.00
+| 0941 |[Valid Mountain Array](src/main/kotlin/g0901_1000/s0941_valid_mountain_array/Solution.kt)| Easy | Array | 251 | 51.94
+| 0940 |[Distinct Subsequences II](src/main/kotlin/g0901_1000/s0940_distinct_subsequences_ii/Solution.kt)| Hard | String, Dynamic_Programming | 177 | 100.00
 | 0939 |[Minimum Area Rectangle](src/main/kotlin/g0901_1000/s0939_minimum_area_rectangle/Solution.kt)| Medium | Array, Hash_Table, Math, Sorting, Geometry | 461 | 100.00
 | 0938 |[Range Sum of BST](src/main/kotlin/g0901_1000/s0938_range_sum_of_bst/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Udemy_Tree_Stack_Queue | 356 | 55.36
 | 0937 |[Reorder Data in Log Files](src/main/kotlin/g0901_1000/s0937_reorder_data_in_log_files/Solution.kt)| Easy | Array, String, Sorting | 205 | 81.82

src/main/kotlin/g0901_1000/s0940_distinct_subsequences_ii/Solution.kt

@@ -0,0 +1,25 @@
+package g0901_1000.s0940_distinct_subsequences_ii
+
+// #Hard #String #Dynamic_Programming #2023_04_29_Time_177_ms_(100.00%)_Space_35.9_MB_(100.00%)
+
+class Solution {
+    fun distinctSubseqII(s: String): Int {
+        val n = s.length
+        val mod = 1000000007
+        val arr = IntArray(26)
+        for (i in 0 until n) {
+            val x = s[i].code - 'a'.code
+            var sum: Long = 0
+            arr[x] += 1
+            for (j in 0..25) {
+                sum = (sum + arr[j]) % mod
+            }
+            arr[x] = sum.toInt()
+        }
+        var total: Long = 0
+        for (x in arr) {
+            total = (total + x) % mod
+        }
+        return total.toInt()
+    }
+}

src/main/kotlin/g0901_1000/s0940_distinct_subsequences_ii/readme.md

@@ -0,0 +1,36 @@
+940\. Distinct Subsequences II
+
+Hard
+
+Given a string s, return _the number of **distinct non-empty subsequences** of_ `s`. Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+A **subsequence** of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., `"ace"` is a subsequence of <code>"<ins>a</ins>b<ins>c</ins>d<ins>e</ins>"</code> while `"aec"` is not.
+
+**Example 1:**
+
+**Input:** s = "abc"
+
+**Output:** 7
+
+**Explanation:** The 7 distinct subsequences are "a", "b", "c", "ab", "ac", "bc", and "abc".
+
+**Example 2:**
+
+**Input:** s = "aba"
+
+**Output:** 6
+
+**Explanation:** The 6 distinct subsequences are "a", "b", "ab", "aa", "ba", and "aba".
+
+**Example 3:**
+
+**Input:** s = "aaa"
+
+**Output:** 3
+
+**Explanation:** The 3 distinct subsequences are "a", "aa" and "aaa".
+
+**Constraints:**
+
+*   `1 <= s.length <= 2000`
+*   `s` consists of lowercase English letters.

src/main/kotlin/g0901_1000/s0941_valid_mountain_array/Solution.kt

@@ -0,0 +1,23 @@
+package g0901_1000.s0941_valid_mountain_array
+
+// #Easy #Array #2023_04_29_Time_251_ms_(51.94%)_Space_55.5_MB_(7.75%)
+
+class Solution {
+    fun validMountainArray(arr: IntArray): Boolean {
+        var i = 0
+        var flag1 = false
+        var flag2 = false
+        while (i < arr.size - 1 && arr[i] < arr[i + 1]) {
+            flag1 = true
+            i++
+        }
+        while (i < arr.size - 1 && arr[i] > arr[i + 1]) {
+            flag2 = true
+            i++
+        }
+        if (i < arr.size - 1) {
+            return false
+        }
+        return !(!flag1 || !flag2)
+    }
+}

src/main/kotlin/g0901_1000/s0941_valid_mountain_array/readme.md

@@ -0,0 +1,37 @@
+941\. Valid Mountain Array
+
+Easy
+
+Given an array of integers `arr`, return _`true` if and only if it is a valid mountain array_.
+
+Recall that arr is a mountain array if and only if:
+
+*   `arr.length >= 3`
+*   There exists some `i` with `0 < i < arr.length - 1` such that:
+    *   `arr[0] < arr[1] < ... < arr[i - 1] < arr[i]`
+    *   `arr[i] > arr[i + 1] > ... > arr[arr.length - 1]`
+
+![](https://assets.leetcode.com/uploads/2019/10/20/hint_valid_mountain_array.png)
+
+**Example 1:**
+
+**Input:** arr = [2,1]
+
+**Output:** false
+
+**Example 2:**
+
+**Input:** arr = [3,5,5]
+
+**Output:** false
+
+**Example 3:**
+
+**Input:** arr = [0,3,2,1]
+
+**Output:** true
+
+**Constraints:**
+
+*   <code>1 <= arr.length <= 10<sup>4</sup></code>
+*   <code>0 <= arr[i] <= 10<sup>4</sup></code>

src/main/kotlin/g0901_1000/s0942_di_string_match/Solution.kt

@@ -0,0 +1,36 @@
+package g0901_1000.s0942_di_string_match
+
+// #Easy #Array #String #Math #Greedy #Two_Pointers
+// #2023_04_29_Time_202_ms_(80.00%)_Space_45.6_MB_(10.00%)
+
+class Solution {
+    fun diStringMatch(s: String): IntArray {
+        val arr = IntArray(s.length + 1)
+        var max = s.length
+        for (i in s.indices) {
+            if (s[i] == 'D') {
+                arr[i] = max
+                max--
+            }
+        }
+        run {
+            var i = s.length - 1
+            while (i >= 0 && max > 0) {
+                if (s[i] == 'I' && arr[i + 1] == 0) {
+                    arr[i + 1] = max
+                    max--
+                }
+                i--
+            }
+        }
+        var i = 0
+        while (i < arr.size && max > 0) {
+            if (arr[i] == 0) {
+                arr[i] = max
+                max--
+            }
+            i++
+        }
+        return arr
+    }
+}

src/main/kotlin/g0901_1000/s0942_di_string_match/readme.md

@@ -0,0 +1,33 @@
+942\. DI String Match
+
+Easy
+
+A permutation `perm` of `n + 1` integers of all the integers in the range `[0, n]` can be represented as a string `s` of length `n` where:
+
+*   `s[i] == 'I'` if `perm[i] < perm[i + 1]`, and
+*   `s[i] == 'D'` if `perm[i] > perm[i + 1]`.
+
+Given a string `s`, reconstruct the permutation `perm` and return it. If there are multiple valid permutations perm, return **any of them**.
+
+**Example 1:**
+
+**Input:** s = "IDID"
+
+**Output:** [0,4,1,3,2]
+
+**Example 2:**
+
+**Input:** s = "III"
+
+**Output:** [0,1,2,3]
+
+**Example 3:**
+
+**Input:** s = "DDI"
+
+**Output:** [3,2,0,1]
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s[i]` is either `'I'` or `'D'`.

src/main/kotlin/g0901_1000/s0943_find_the_shortest_superstring/Solution.kt

@@ -0,0 +1,72 @@
+package g0901_1000.s0943_find_the_shortest_superstring
+
+// #Hard #Array #String #Dynamic_Programming #Bit_Manipulation #Bitmask
+// #2023_04_29_Time_1290_ms_(100.00%)_Space_309.3_MB_(100.00%)
+
+class Solution {
+    fun shortestSuperstring(words: Array<String>): String? {
+        val l = words.size
+        var state = 0
+        for (i in 0 until l) {
+            state = state or (1 shl i)
+        }
+        val map: MutableMap<String?, String?> = HashMap()
+        return solveTPS(words, state, "", map, l)
+    }
+
+    private fun solveTPS(
+        words: Array<String>,
+        state: Int,
+        startWord: String,
+        map: MutableMap<String?, String?>,
+        l: Int
+    ): String? {
+        val key = "$startWord|$state"
+        if (state == 0) {
+            return startWord
+        }
+        if (map[key] != null) {
+            return map[key]
+        }
+        var minLenWord: String? = ""
+        for (i in 0 until l) {
+            if (state shr i and 1 == 1) {
+                val takenState = state and (1 shl i).inv()
+                val result = solveTPS(words, takenState, words[i], map, l)
+                val tmp = mergeAndGet(startWord, result)
+                if (minLenWord!!.isEmpty() || minLenWord.length > tmp.length) {
+                    minLenWord = tmp
+                }
+            }
+        }
+        map[key] = minLenWord
+        return minLenWord
+    }
+
+    private fun mergeAndGet(word: String, result: String?): String {
+        val l = word.length
+        val t = result!!.length
+        if (result.contains(word)) {
+            return result
+        }
+        if (word.contains(result)) {
+            return word
+        }
+        var found = l
+        for (k in 0 until l) {
+            var i = k
+            var j = 0
+            while (i < l && j < t) {
+                if (word[i] == result[j]) {
+                    i++
+                    j++
+                } else break
+            }
+            if (i == l) {
+                found = k
+                break
+            }
+        }
+        return word.substring(0, found) + result
+    }
+}

src/main/kotlin/g0901_1000/s0943_find_the_shortest_superstring/readme.md

@@ -0,0 +1,28 @@
+943\. Find the Shortest Superstring
+
+Hard
+
+Given an array of strings `words`, return _the smallest string that contains each string in_ `words` _as a substring_. If there are multiple valid strings of the smallest length, return **any of them**.
+
+You may assume that no string in `words` is a substring of another string in `words`.
+
+**Example 1:**
+
+**Input:** words = ["alex","loves","leetcode"]
+
+**Output:** "alexlovesleetcode"
+
+**Explanation:** All permutations of "alex","loves","leetcode" would also be accepted.
+
+**Example 2:**
+
+**Input:** words = ["catg","ctaagt","gcta","ttca","atgcatc"]
+
+**Output:** "gctaagttcatgcatc"
+
+**Constraints:**
+
+*   `1 <= words.length <= 12`
+*   `1 <= words[i].length <= 20`
+*   `words[i]` consists of lowercase English letters.
+*   All the strings of `words` are **unique**.

src/test/kotlin/g0901_1000/s0940_distinct_subsequences_ii/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0901_1000.s0940_distinct_subsequences_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun distinctSubseqII() {
+        assertThat(Solution().distinctSubseqII("abc"), equalTo(7))
+    }
+
+    @Test
+    fun distinctSubseqII2() {
+        assertThat(Solution().distinctSubseqII("aba"), equalTo(6))
+    }
+
+    @Test
+    fun distinctSubseqII3() {
+        assertThat(Solution().distinctSubseqII("aaa"), equalTo(3))
+    }
+}

src/test/kotlin/g0901_1000/s0941_valid_mountain_array/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0901_1000.s0941_valid_mountain_array
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun validMountainArray() {
+        assertThat(Solution().validMountainArray(intArrayOf(2, 1)), equalTo(false))
+    }
+
+    @Test
+    fun validMountainArray2() {
+        assertThat(Solution().validMountainArray(intArrayOf(3, 5, 5)), equalTo(false))
+    }
+
+    @Test
+    fun validMountainArray3() {
+        assertThat(Solution().validMountainArray(intArrayOf(0, 3, 2, 1)), equalTo(true))
+    }
+}

src/test/kotlin/g0901_1000/s0942_di_string_match/SolutionTest.kt

@@ -0,0 +1,28 @@
+package g0901_1000.s0942_di_string_match
+
+import com_github_leetcode.CommonUtils
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun diStringMatch() {
+        assertThat(
+            CommonUtils().compareArray(
+                Solution().diStringMatch("IDID"), intArrayOf(0, 4, 1, 3, 2)
+            ),
+            equalTo(true)
+        )
+    }
+
+    @Test
+    fun diStringMatch2() {
+        assertThat(Solution().diStringMatch("III"), equalTo(intArrayOf(0, 1, 2, 3)))
+    }
+
+    @Test
+    fun diStringMatch3() {
+        assertThat(Solution().diStringMatch("DDI"), equalTo(intArrayOf(3, 2, 0, 1)))
+    }
+}