Added tasks 211, 212, 213, 214.

Author: ThanhNIT

README.md

@@ -245,6 +245,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0198 |[House Robber](src/main/kotlin/g0101_0200/s0198_house_robber/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming | 156 | 92.24
+| 0213 |[House Robber II](src/main/kotlin/g0201_0300/s0213_house_robber_ii/Solution.kt)| Medium | Array, Dynamic_Programming | 257 | 59.62
 
 #### Day 4
 
@@ -1043,6 +1044,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 0139 |[Word Break](src/main/kotlin/g0101_0200/s0139_word_break/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Dynamic_Programming, Trie, Memoization | 197 | 87.17
 | 0152 |[Maximum Product Subarray](src/main/kotlin/g0101_0200/s0152_maximum_product_subarray/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming | 253 | 88.42
 | 0198 |[House Robber](src/main/kotlin/g0101_0200/s0198_house_robber/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming | 156 | 92.24
+| 0213 |[House Robber II](src/main/kotlin/g0201_0300/s0213_house_robber_ii/Solution.kt)| Medium | Array, Dynamic_Programming | 257 | 59.62
 | 0070 |[Climbing Stairs](src/main/kotlin/g0001_0100/s0070_climbing_stairs/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Math, Memoization | 127 | 97.06
 | 0064 |[Minimum Path Sum](src/main/kotlin/g0001_0100/s0064_minimum_path_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Matrix | 222 | 95.70
 | 0300 |[Longest Increasing Subsequence](src/main/kotlin/g0201_0300/s0300_longest_increasing_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Binary_Search | 318 | 82.28
@@ -1483,6 +1485,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0213 |[House Robber II](src/main/kotlin/g0201_0300/s0213_house_robber_ii/Solution.kt)| Medium | Array, Dynamic_Programming | 257 | 59.62
 | 0055 |[Jump Game](src/main/kotlin/g0001_0100/s0055_jump_game/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Greedy | 670 | 66.67
 
 #### Day 13 Dynamic Programming
@@ -1576,6 +1579,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.5'
 | 0226 |[Invert Binary Tree](src/main/kotlin/g0201_0300/s0226_invert_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Data_Structure_I_Day_12_Tree, Level_2_Day_6_Tree, Udemy_Tree_Stack_Queue | 233 | 54.90
 | 0221 |[Maximal Square](src/main/kotlin/g0201_0300/s0221_maximal_square/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_16 | 614 | 44.00
 | 0215 |[Kth Largest Element in an Array](src/main/kotlin/g0201_0300/s0215_kth_largest_element_in_an_array/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Heap_Priority_Queue, Divide_and_Conquer, Quickselect, Data_Structure_II_Day_20_Heap_Priority_Queue | 839 | 34.43
+| 0214 |[Shortest Palindrome](src/main/kotlin/g0201_0300/s0214_shortest_palindrome/Solution.kt)| Hard | String, Hash_Function, String_Matching, Rolling_Hash | 278 | 100.00
+| 0213 |[House Robber II](src/main/kotlin/g0201_0300/s0213_house_robber_ii/Solution.kt)| Medium | Array, Dynamic_Programming, Algorithm_II_Day_12_Dynamic_Programming, Dynamic_Programming_I_Day_3, Udemy_Dynamic_Programming | 257 | 59.62
+| 0212 |[Word Search II](src/main/kotlin/g0201_0300/s0212_word_search_ii/Solution.kt)| Hard | Top_Interview_Questions, Array, String, Matrix, Backtracking, Trie | 268 | 100.00
+| 0211 |[Design Add and Search Words Data Structure](src/main/kotlin/g0201_0300/s0211_design_add_and_search_words_data_structure/WordDictionary.kt)| Medium | String, Depth_First_Search, Design, Trie | 2256 | 87.04
 | 0210 |[Course Schedule II](src/main/kotlin/g0201_0300/s0210_course_schedule_ii/Solution.kt)| Medium | Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort, Level_2_Day_11_Graph/BFS/DFS | 266 | 96.32
 | 0209 |[Minimum Size Subarray Sum](src/main/kotlin/g0201_0300/s0209_minimum_size_subarray_sum/Solution.kt)| Medium | Array, Binary_Search, Prefix_Sum, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Binary_Search_II_Day_1 | 315 | 96.73
 | 0208 |[Implement Trie (Prefix Tree)](src/main/kotlin/g0201_0300/s0208_implement_trie_prefix_tree/Trie.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Design, Trie, Level_2_Day_16_Design, Udemy_Trie_and_Heap | 689 | 61.00

src/main/kotlin/g0201_0300/s0211_design_add_and_search_words_data_structure/WordDictionary.kt

@@ -0,0 +1,54 @@
+package g0201_0300.s0211_design_add_and_search_words_data_structure
+
+// #Medium #String #Depth_First_Search #Design #Trie
+// #2022_10_24_Time_2256_ms_(87.04%)_Space_237.4_MB_(83.33%)
+
+class WordDictionary {
+    class TrieNode() {
+        val children = Array<TrieNode?>(26) { null }
+        var isWord = false
+    }
+
+    val trieTree = TrieNode()
+
+    fun addWord(word: String) {
+        var p = trieTree
+
+        for (w in word) {
+            val i = w - 'a'
+            if (p.children[i] == null) p.children[i] = TrieNode()
+            p = p.children[i]!!
+        }
+
+        p.isWord = true
+    }
+
+    fun search(word: String): Boolean {
+        fun dfs(p: TrieNode?, start: Int): Boolean {
+            if (p == null) return false
+
+            if (start == word.length) return p.isWord
+
+            if (word[start] == '.') {
+                for (i in 0..25) {
+                    if (dfs(p.children[i], start + 1)) {
+                        return true
+                    }
+                }
+                return false
+            } else {
+                val i = word[start] - 'a'
+                return dfs(p.children[i], start + 1)
+            }
+        }
+
+        return dfs(trieTree, 0)
+    }
+}
+
+/*
+ * Your WordDictionary object will be instantiated and called as such:
+ * var obj = WordDictionary()
+ * obj.addWord(word)
+ * var param_2 = obj.search(word)
+ */

src/main/kotlin/g0201_0300/s0211_design_add_and_search_words_data_structure/readme.md

@@ -0,0 +1,39 @@
+211\. Design Add and Search Words Data Structure
+
+Medium
+
+Design a data structure that supports adding new words and finding if a string matches any previously added string.
+
+Implement the `WordDictionary` class:
+
+*   `WordDictionary()` Initializes the object.
+*   `void addWord(word)` Adds `word` to the data structure, it can be matched later.
+*   `bool search(word)` Returns `true` if there is any string in the data structure that matches `word` or `false` otherwise. `word` may contain dots `'.'` where dots can be matched with any letter.
+
+**Example:**
+
+**Input**
+
+    ["WordDictionary","addWord","addWord","addWord","search","search","search","search"] [[],["bad"],["dad"],["mad"],["pad"],["bad"],[".ad"],["b.."]]
+
+**Output**
+
+    [null,null,null,null,false,true,true,true]
+
+**Explanation**
+
+    WordDictionary wordDictionary = new WordDictionary();
+    wordDictionary.addWord("bad");
+    wordDictionary.addWord("dad");
+    wordDictionary.addWord("mad");
+    wordDictionary.search("pad"); // return False
+    wordDictionary.search("bad"); // return True
+    wordDictionary.search(".ad"); // return True
+    wordDictionary.search("b.."); // return True 
+
+**Constraints:**
+
+*   `1 <= word.length <= 500`
+*   `word` in `addWord` consists lower-case English letters.
+*   `word` in `search` consist of `'.'` or lower-case English letters.
+*   At most `50000` calls will be made to `addWord` and `search`.

src/main/kotlin/g0201_0300/s0212_word_search_ii/Solution.kt

@@ -0,0 +1,58 @@
+package g0201_0300.s0212_word_search_ii
+
+// #Hard #Top_Interview_Questions #Array #String #Matrix #Backtracking #Trie
+// #2022_10_24_Time_268_ms_(100.00%)_Space_37.5_MB_(95.08%)
+
+class Solution {
+    private var root: Tree? = null
+    fun findWords(board: Array<CharArray>, words: Array<String?>): List<String> {
+        if (board.size < 1 || board[0].size < 1) {
+            return emptyList()
+        }
+        root = Tree()
+        for (word in words) {
+            Tree.addWord(root, word!!)
+        }
+        val collected: MutableList<String> = ArrayList()
+        for (i in board.indices) {
+            for (j in board[0].indices) {
+                dfs(board, i, j, root, collected)
+            }
+        }
+        return collected
+    }
+
+    private fun dfs(board: Array<CharArray>, i: Int, j: Int, cur: Tree?, collected: MutableList<String>) {
+        var cur: Tree? = cur
+        val c = board[i][j]
+        if (c == '-') {
+            return
+        }
+        cur = cur!!.getChild(c)
+        if (cur == null) {
+            return
+        }
+        if (cur.end != null) {
+            val s: String = cur.end!!
+            collected.add(s)
+            cur.end = null
+            if (cur.len() === 0) {
+                Tree.deleteWord(root, s)
+            }
+        }
+        board[i][j] = '-'
+        if (i > 0) {
+            dfs(board, i - 1, j, cur, collected)
+        }
+        if (i + 1 < board.size) {
+            dfs(board, i + 1, j, cur, collected)
+        }
+        if (j > 0) {
+            dfs(board, i, j - 1, cur, collected)
+        }
+        if (j + 1 < board[0].size) {
+            dfs(board, i, j + 1, cur, collected)
+        }
+        board[i][j] = c
+    }
+}

src/main/kotlin/g0201_0300/s0212_word_search_ii/Tree.kt

@@ -0,0 +1,53 @@
+package g0201_0300.s0212_word_search_ii
+
+class Tree {
+    private var children: Array<Tree?>? = null
+    var end: String? = null
+    private var length = 0
+    private fun addChild(c: Char): Tree? {
+        val i = c.code - 'a'.code
+        if (children == null) {
+            children = arrayOfNulls(26)
+        }
+        if (children!![i] == null) {
+            children!![i] = Tree()
+            ++length
+        }
+        return children!![i]
+    }
+
+    fun getChild(c: Char): Tree? {
+        return if (children == null) null else children!![c.code - 'a'.code]
+    }
+
+    fun len(): Int {
+        return length
+    }
+
+    companion object {
+        fun addWord(root: Tree?, word: String) {
+            var t = root
+            for (c in word.toCharArray()) {
+                t = t!!.addChild(c)
+            }
+            t!!.end = word
+        }
+
+        fun deleteWord(root: Tree?, word: String) {
+            var root = root
+            var toDelOn = root
+            var toDel = word[0]
+            for (c in word.toCharArray()) {
+                if (root!!.length > 1) {
+                    toDelOn = root
+                    toDel = c
+                }
+                root = root.getChild(c)
+                requireNotNull(root)
+            }
+            toDelOn!!.children!![toDel.code - 'a'.code] = null
+            --toDelOn.length
+            require(root!!.length == 0)
+        }
+    }
+}

src/main/kotlin/g0201_0300/s0212_word_search_ii/readme.md

@@ -0,0 +1,34 @@
+212\. Word Search II
+
+Hard
+
+Given an `m x n` `board` of characters and a list of strings `words`, return _all words on the board_.
+
+Each word must be constructed from letters of sequentially adjacent cells, where **adjacent cells** are horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/07/search1.jpg)
+
+**Input:** board = [["o","a","a","n"],["e","t","a","e"],["i","h","k","r"],["i","f","l","v"]], words = ["oath","pea","eat","rain"]
+
+**Output:** ["eat","oath"]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/07/search2.jpg)
+
+**Input:** board = [["a","b"],["c","d"]], words = ["abcb"]
+
+**Output:** []
+
+**Constraints:**
+
+*   `m == board.length`
+*   `n == board[i].length`
+*   `1 <= m, n <= 12`
+*   `board[i][j]` is a lowercase English letter.
+*   <code>1 <= words.length <= 3 * 10<sup>4</sup></code>
+*   `1 <= words[i].length <= 10`
+*   `words[i]` consists of lowercase English letters.
+*   All the strings of `words` are unique.

src/main/kotlin/g0201_0300/s0213_house_robber_ii/Solution.kt

@@ -0,0 +1,42 @@
+package g0201_0300.s0213_house_robber_ii
+
+// #Medium #Array #Dynamic_Programming #Algorithm_II_Day_12_Dynamic_Programming
+// #Dynamic_Programming_I_Day_3 #Udemy_Dynamic_Programming
+// #2022_10_24_Time_257_ms_(59.62%)_Space_34.3_MB_(80.77%)
+
+class Solution {
+    fun rob(nums: IntArray): Int {
+        val n = nums.size
+        if (n == 0) {
+            return 0
+        }
+        if (n == 1) {
+            return nums[0]
+        }
+        if (n == 2) {
+            return Math.max(nums[0], nums[1])
+        }
+        if (n == 3) {
+            return Math.max(nums[0], Math.max(nums[1], nums[2]))
+        }
+        var max = Int.MIN_VALUE
+        val inc = IntArray(n)
+        val exc = IntArray(n)
+        inc[0] = nums[0]
+        exc[0] = 0
+        inc[1] = nums[0]
+        exc[1] = nums[1]
+        inc[2] = nums[2] + nums[0]
+        exc[2] = nums[2]
+        for (i in 3 until n - 1) {
+            inc[i] = Math.max(inc[i - 2], inc[i - 3]) + nums[i]
+            exc[i] = Math.max(exc[i - 2], exc[i - 3]) + nums[i]
+        }
+        inc[n - 1] = inc[n - 2]
+        exc[n - 1] = Math.max(exc[n - 3], exc[n - 4]) + nums[n - 1]
+        for (i in 0 until n) {
+            max = Math.max(max, Math.max(inc[i], exc[i]))
+        }
+        return max
+    }
+}

src/main/kotlin/g0201_0300/s0213_house_robber_ii/readme.md

@@ -0,0 +1,34 @@
+213\. House Robber II
+
+Medium
+
+You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed. All houses at this place are **arranged in a circle.** That means the first house is the neighbor of the last one. Meanwhile, adjacent houses have a security system connected, and **it will automatically contact the police if two adjacent houses were broken into on the same night**.
+
+Given an integer array `nums` representing the amount of money of each house, return _the maximum amount of money you can rob tonight **without alerting the police**_.
+
+**Example 1:**
+
+**Input:** nums = [2,3,2]
+
+**Output:** 3
+
+**Explanation:** You cannot rob house 1 (money = 2) and then rob house 3 (money = 2), because they are adjacent houses.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,1]
+
+**Output:** 4
+
+**Explanation:** Rob house 1 (money = 1) and then rob house 3 (money = 3). Total amount you can rob = 1 + 3 = 4.
+
+**Example 3:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 3
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `0 <= nums[i] <= 1000`