Added tasks 210-222

Author: ThanhNIT

README.md

@@ -152,6 +152,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0222 |[Count Complete Tree Nodes](src/main/ts/g0201_0300/s0222_count_complete_tree_nodes/solution.ts)| Easy | Depth_First_Search, Tree, Binary_Search, Binary_Tree | 0 | 100.00
 
 #### Day 11
 
@@ -801,6 +802,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0210 |[Course Schedule II](src/main/ts/g0201_0300/s0210_course_schedule_ii/solution.ts)| Medium | Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort | 2 | 99.76
 
 #### Day 12 Dynamic Programming
 
@@ -1088,6 +1090,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | 0049 |[Group Anagrams](src/main/ts/g0001_0100/s0049_group_anagrams/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, String, Hash_Table, Sorting, Big_O_Time_O(n\*k_log_k)_Space_O(n) | 27 | 78.99
 | 0001 |[Two Sum](src/main/ts/g0001_0100/s0001_two_sum/solution.ts)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table, Big_O_Time_O(n)_Space_O(n), AI_can_be_used_to_solve_the_task | 1 | 89.70
 | 0202 |[Happy Number](src/main/ts/g0201_0300/s0202_happy_number/solution.ts)| Easy | Top_Interview_Questions, Hash_Table, Math, Two_Pointers | 0 | 100.00
+| 0219 |[Contains Duplicate II](src/main/ts/g0201_0300/s0219_contains_duplicate_ii/solution.ts)| Easy | Array, Hash_Table, Sliding_Window | 17 | 79.29
 | 0128 |[Longest Consecutive Sequence](src/main/ts/g0101_0200/s0128_longest_consecutive_sequence/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table, Union_Find, Big_O_Time_O(N_log_N)_Space_O(1) | 34 | 90.07
 
 #### Top Interview 150 Intervals
@@ -1137,6 +1140,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | 0129 |[Sum Root to Leaf Numbers](src/main/ts/g0101_0200/s0129_sum_root_to_leaf_numbers/solution.ts)| Medium | Depth_First_Search, Tree, Binary_Tree | 0 | 100.00
 | 0124 |[Binary Tree Maximum Path Sum](src/main/ts/g0101_0200/s0124_binary_tree_maximum_path_sum/solution.ts)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Depth_First_Search, Tree, Binary_Tree, Big_O_Time_O(N)_Space_O(N) | 2 | 71.11
 | 0173 |[Binary Search Tree Iterator](src/main/ts/g0101_0200/s0173_binary_search_tree_iterator/solution.ts)| Medium | Tree, Binary_Tree, Stack, Design, Binary_Search_Tree, Iterator | 6 | 98.16
+| 0222 |[Count Complete Tree Nodes](src/main/ts/g0201_0300/s0222_count_complete_tree_nodes/solution.ts)| Easy | Depth_First_Search, Tree, Binary_Search, Binary_Tree | 0 | 100.00
 | 0236 |[Lowest Common Ancestor of a Binary Tree](src/main/ts/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/solution.ts)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Big_O_Time_O(n)_Space_O(n) | 61 | 75.97
 
 #### Top Interview 150 Binary Tree BFS
@@ -1160,6 +1164,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 |-|-|-|-|-|-
 | 0200 |[Number of Islands](src/main/ts/g0101_0200/s0200_number_of_islands/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find, Big_O_Time_O(M\*N)_Space_O(M\*N) | 57 | 93.94
 | 0207 |[Course Schedule](src/main/ts/g0201_0300/s0207_course_schedule/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort, Big_O_Time_O(N)_Space_O(N) | 11 | 81.08
+| 0210 |[Course Schedule II](src/main/ts/g0201_0300/s0210_course_schedule_ii/solution.ts)| Medium | Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort | 2 | 99.76
 
 #### Top Interview 150 Graph BFS
 
@@ -1172,6 +1177,8 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0208 |[Implement Trie (Prefix Tree)](src/main/ts/g0201_0300/s0208_implement_trie_prefix_tree/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Design, Trie, Big_O_Time_O(word.length())_or_O(prefix.length())_Space_O(N) | 48 | 63.95
+| 0211 |[Design Add and Search Words Data Structure](src/main/ts/g0201_0300/s0211_design_add_and_search_words_data_structure/solution.ts)| Medium | String, Depth_First_Search, Design, Trie | 450 | 92.88
+| 0212 |[Word Search II](src/main/ts/g0201_0300/s0212_word_search_ii/solution.ts)| Hard | Top_Interview_Questions, Array, String, Matrix, Backtracking, Trie | ew 150 | ew 150 Trie
 
 #### Top Interview 150 Backtracking
 
@@ -1741,8 +1748,13 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | 0234 |[Palindrome Linked List](src/main/ts/g0201_0300/s0234_palindrome_linked_list/solution.ts)| Easy | Top_100_Liked_Questions, Two_Pointers, Stack, Linked_List, Recursion, Level_2_Day_3_Linked_List, Udemy_Linked_List, Big_O_Time_O(n)_Space_O(1) | 3 | 92.85
 | 0230 |[Kth Smallest Element in a BST](src/main/ts/g0201_0300/s0230_kth_smallest_element_in_a_bst/solution.ts)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_II_Day_17_Tree, Level_2_Day_9_Binary_Search_Tree, Top_Interview_150_Binary_Search_Tree, Big_O_Time_O(n)_Space_O(n) | 0 | 100.00
 | 0226 |[Invert Binary Tree](src/main/ts/g0201_0300/s0226_invert_binary_tree/solution.ts)| 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, Top_Interview_150_Binary_Tree_General, Big_O_Time_O(n)_Space_O(n) | 0 | 100.00
+| 0222 |[Count Complete Tree Nodes](src/main/ts/g0201_0300/s0222_count_complete_tree_nodes/solution.ts)| Easy | Depth_First_Search, Tree, Binary_Search, Binary_Tree, Binary_Search_II_Day_10, Top_Interview_150_Binary_Tree_General | 0 | 100.00
 | 0221 |[Maximal Square](src/main/ts/g0201_0300/s0221_maximal_square/solution.ts)| Medium | Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_16, Top_Interview_150_Multidimensional_DP, Big_O_Time_O(m\*n)_Space_O(m\*n) | 18 | 59.02
+| 0219 |[Contains Duplicate II](src/main/ts/g0201_0300/s0219_contains_duplicate_ii/solution.ts)| Easy | Array, Hash_Table, Sliding_Window, Top_Interview_150_Hashmap | 17 | 79.29
 | 0215 |[Kth Largest Element in an Array](src/main/ts/g0201_0300/s0215_kth_largest_element_in_an_array/solution.ts)| 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, Top_Interview_150_Heap, Big_O_Time_O(n\*log(n))_Space_O(log(n)) | 4 | 99.64
+| 0212 |[Word Search II](src/main/ts/g0201_0300/s0212_word_search_ii/solution.ts)| Hard | Top_Interview_Questions, Array, String, Matrix, Backtracking, Trie | ew 150 | ew 150 Trie
+| 0211 |[Design Add and Search Words Data Structure](src/main/ts/g0201_0300/s0211_design_add_and_search_words_data_structure/solution.ts)| Medium | String, Depth_First_Search, Design, Trie, Top_Interview_150_Trie | 450 | 92.88
+| 0210 |[Course Schedule II](src/main/ts/g0201_0300/s0210_course_schedule_ii/solution.ts)| Medium | Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort, Level_2_Day_11_Graph/BFS/DFS, Top_Interview_150_Graph_General | 2 | 99.76
 | 0209 |[Minimum Size Subarray Sum](src/main/ts/g0201_0300/s0209_minimum_size_subarray_sum/solution.ts)| Medium | Array, Binary_Search, Prefix_Sum, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Binary_Search_II_Day_1, Top_Interview_150_Sliding_Window | 2 | 88.11
 | 0208 |[Implement Trie (Prefix Tree)](src/main/ts/g0201_0300/s0208_implement_trie_prefix_tree/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Design, Trie, Level_2_Day_16_Design, Udemy_Trie_and_Heap, Top_Interview_150_Trie, Big_O_Time_O(word.length())_or_O(prefix.length())_Space_O(N) | 48 | 63.95
 | 0207 |[Course Schedule](src/main/ts/g0201_0300/s0207_course_schedule/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Breadth_First_Search, Graph, Topological_Sort, Top_Interview_150_Graph_General, Big_O_Time_O(N)_Space_O(N) | 11 | 81.08

src/main/ts/g0201_0300/s0210_course_schedule_ii/readme.md

@@ -0,0 +1,46 @@
+210\. Course Schedule II
+
+Medium
+
+There are a total of `numCourses` courses you have to take, labeled from `0` to `numCourses - 1`. You are given an array `prerequisites` where <code>prerequisites[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that you **must** take course <code>b<sub>i</sub></code> first if you want to take course <code>a<sub>i</sub></code>.
+
+*   For example, the pair `[0, 1]`, indicates that to take course `0` you have to first take course `1`.
+
+Return _the ordering of courses you should take to finish all courses_. If there are many valid answers, return **any** of them. If it is impossible to finish all courses, return **an empty array**.
+
+**Example 1:**
+
+**Input:** numCourses = 2, prerequisites = [[1,0]]
+
+**Output:** [0,1]
+
+**Explanation:**
+
+    There are a total of 2 courses to take. To take course 1 you should have finished course 0.
+    So the correct course order is [0,1].
+
+**Example 2:**
+
+**Input:** numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
+
+**Output:** [0,2,1,3]
+
+**Explanation:**
+
+    There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
+    So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].
+
+**Example 3:**
+
+**Input:** numCourses = 1, prerequisites = []
+
+**Output:** [0] 
+
+**Constraints:**
+
+*   `1 <= numCourses <= 2000`
+*   `0 <= prerequisites.length <= numCourses * (numCourses - 1)`
+*   `prerequisites[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < numCourses</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   All the pairs <code>[a<sub>i</sub>, b<sub>i</sub>]</code> are **distinct**.

src/main/ts/g0201_0300/s0210_course_schedule_ii/solution.ts

@@ -0,0 +1,34 @@
+// #Medium #Top_Interview_Questions #Depth_First_Search #Breadth_First_Search #Graph
+// #Topological_Sort #Level_2_Day_11_Graph/BFS/DFS #Top_Interview_150_Graph_General
+// #2025_04_12_Time_2_ms_(99.76%)_Space_58.61_MB_(86.54%)
+
+function findOrder(numCourses: number, prerequisites: number[][]): number[] {
+    let sortedOrder: number[] = []
+    if (numCourses < 0) return sortedOrder
+    let inDegree = new Array(numCourses).fill(0),
+        graph = new Array(numCourses).fill(0).map(() => new Array()),
+        source = new Array<number>()
+    prerequisites.forEach((course: number[]) => {
+        graph[course[1]].push(course[0])
+        inDegree[course[0]]++
+    })
+    inDegree.forEach((value: number, index: number) => {
+        if (value === 0) {
+            source.push(index)
+        }
+    })
+    while (source.length > 0) {
+        const course = source.shift()
+        if (course === undefined) break
+        sortedOrder.push(course)
+        graph[course].forEach((val) => {
+            inDegree[val]--
+            if (inDegree[val] === 0) {
+                source.push(val)
+            }
+        })
+    }
+    return sortedOrder.length === numCourses ? sortedOrder : []
+}
+
+export { findOrder }

src/main/ts/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/ts/g0201_0300/s0211_design_add_and_search_words_data_structure/solution.ts

@@ -0,0 +1,57 @@
+// #Medium #String #Depth_First_Search #Design #Trie #Top_Interview_150_Trie
+// #2025_04_12_Time_450_ms_(92.88%)_Space_92.76_MB_(88.14%)
+
+interface TrieNode {
+    [key: string]: TrieNode | boolean
+}
+
+class WordDictionary {
+    root: TrieNode
+
+    constructor() {
+        this.root = {}
+    }
+
+    addWord(word: string): void {
+        let current = this.root
+        for (let i = 0; i < word.length; i++) {
+            const letter = word[i]
+            if (!current.hasOwnProperty(letter)) {
+                current[letter] = {}
+            }
+            current = current[letter] as TrieNode
+        }
+        current.end = true
+    }
+
+    search(word: string): boolean {
+        const searchSubtree = (word: string, index: number, subtree: TrieNode) => {
+            if (word.length === index) {
+                return subtree.hasOwnProperty('end')
+            }
+            const currentLetter = word[index]
+            index += 1
+
+            if (currentLetter === '.') {
+                return Object.keys(subtree).some((letter) => searchSubtree(word, index, subtree[letter] as TrieNode))
+            } else {
+                if (subtree.hasOwnProperty(currentLetter)) {
+                    return searchSubtree(word, index, subtree[currentLetter] as TrieNode)
+                } else {
+                    return false
+                }
+            }
+        }
+
+        return searchSubtree(word, 0, this.root)
+    }
+}
+
+/**
+ * Your WordDictionary object will be instantiated and called as such:
+ * var obj = new WordDictionary()
+ * obj.addWord(word)
+ * var param_2 = obj.search(word)
+ */
+
+export { WordDictionary }

src/main/ts/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/ts/g0201_0300/s0212_word_search_ii/solution.ts

@@ -0,0 +1,104 @@
+// #Hard #Top_Interview_Questions #Array #String #Matrix #Backtracking #Trie #Top_Interview_150_Trie
+// #2025_04_12_Time_62_ms_(99.46%)_Space_60.47_MB_(72.83%)
+
+class Tree {
+    children: Map<string, Tree>
+    end: string | null
+
+    constructor() {
+        this.children = new Map()
+        this.end = null
+    }
+
+    static addWord(node: Tree, word: string): void {
+        let cur = node
+        for (const char of word) {
+            if (!cur.children.has(char)) {
+                cur.children.set(char, new Tree())
+            }
+            cur = cur.children.get(char)!
+        }
+        cur.end = word
+    }
+
+    static deleteWord(node: Tree, word: string): void {
+        const stack: [Tree, string][] = []
+        let cur = node
+        for (const char of word) {
+            const next = cur.children.get(char)
+            if (!next) return
+            stack.push([cur, char])
+            cur = next
+        }
+        cur.end = null
+        for (let i = stack.length - 1; i >= 0; i--) {
+            const [parent, char] = stack[i]
+            const child = parent.children.get(char)!
+            if (child.children.size === 0 && child.end === null) {
+                parent.children.delete(char)
+            } else {
+                break
+            }
+        }
+    }
+
+    getChild(char: string): Tree | null {
+        return this.children.get(char) || null
+    }
+
+    len(): number {
+        return this.children.size
+    }
+}
+
+function findWords(board: string[][], words: string[]): string[] {
+    if (board.length === 0 || board[0].length === 0) {
+        return []
+    }
+    const root = new Tree()
+    for (const word of words) {
+        Tree.addWord(root, word)
+    }
+    const collected: string[] = []
+    for (let i = 0; i < board.length; i++) {
+        for (let j = 0; j < board[0].length; j++) {
+            dfs(board, i, j, root, collected, root)
+        }
+    }
+    return collected
+}
+
+function dfs(board: string[][], i: number, j: number, cur: Tree, collected: string[], root: Tree): void {
+    const c = board[i][j]
+    if (c === '-') {
+        return
+    }
+    const next = cur.getChild(c)
+    if (!next) {
+        return
+    }
+    if (next.end !== null) {
+        collected.push(next.end)
+        const word = next.end
+        next.end = null
+        if (next.len() === 0) {
+            Tree.deleteWord(root, word)
+        }
+    }
+    board[i][j] = '-'
+    if (i > 0) {
+        dfs(board, i - 1, j, next, collected, root)
+    }
+    if (i + 1 < board.length) {
+        dfs(board, i + 1, j, next, collected, root)
+    }
+    if (j > 0) {
+        dfs(board, i, j - 1, next, collected, root)
+    }
+    if (j + 1 < board[0].length) {
+        dfs(board, i, j + 1, next, collected, root)
+    }
+    board[i][j] = c
+}
+
+export { findWords }