Merge pull request #1122 from yolophg/main

[Helena] Week 15

Author: TonyKim9401

alien-dictionary/yolophg.py

@@ -0,0 +1,52 @@
+# Time Complexity: O(N + K) - where N is total number of characters in all words, and K is total number of unique character relations (edges) we derive
+# Space Complexity: O(N + K) - for graph, in-degree map, and heap
+
+class Solution:
+    def alien_order(self, words):
+        # adjacency list, u -> set of v
+        graph = defaultdict(set)  
+        # how many chars come before this one
+        in_degree = {}  
+
+        # initialize in_degree with all unique chars
+        for word in words:
+            for char in word:
+                in_degree[char] = 0
+
+        # compare each adjacent pair of words
+        for i in range(len(words) - 1):
+            w1, w2 = words[i], words[i + 1]
+            min_len = min(len(w1), len(w2))
+            # handle invalid case like ["abc", "ab"]
+            if len(w1) > len(w2) and w1[:min_len] == w2[:min_len]:
+                return ""
+
+            for j in range(min_len):
+                if w1[j] != w2[j]:
+                    # first different char tells us the order
+                    if w2[j] not in graph[w1[j]]:
+                        graph[w1[j]].add(w2[j])
+                        in_degree[w2[j]] += 1
+                    # only first different char matters
+                    break  
+
+        # topological sort (use min heap for smallest lex order)
+        heap = []
+        for char in in_degree:
+            if in_degree[char] == 0:
+                heapq.heappush(heap, char)
+
+        result = []
+        while heap:
+            char = heapq.heappop(heap)
+            result.append(char)
+            for neighbor in sorted(graph[char]):
+                in_degree[neighbor] -= 1
+                if in_degree[neighbor] == 0:
+                    heapq.heappush(heap, neighbor)
+
+        # if we added all characters into result, it's valid
+        if len(result) == len(in_degree):
+            return ''.join(result)
+        else:
+            return ""

design-add-and-search-words-data-structure/yolophg.py

@@ -0,0 +1,43 @@
+# Time Complexity:  O(n) - where n is the length of the word(addWord)
+# Space Complexity: O(N) - where N is the total number of characters inserted
+
+class WordDictionary:
+    def __init__(self):
+        # using a trie (prefix tree) to store all the words
+        self.trie = dict()
+
+    def addWord(self, word: str) -> None:
+        # start from the root of the trie
+        trie = self.trie
+        for letter in word:
+            # if this letter isn't already in the current trie level, add it
+            if letter not in trie:
+                trie[letter] = dict()
+            # move one level deeper
+            trie = trie[letter]
+        # mark the end of the word with a special null character
+        trie['\0'] = dict()
+
+    def internal_search(self, trie: dict, index: int, word: str) -> bool:
+        if index == len(word):
+            # check if this path ends a valid word
+            return '\0' in trie  
+
+        letter = word[index]
+        
+        # if hit a '.', gotta try all possible paths from here
+        if letter == '.':
+            for child in trie.values():
+                if self.internal_search(child, index + 1, word):
+                    return True
+            return False
+        else:
+            # if the letter exists in the current trie level, keep going
+            if letter in trie:
+                return self.internal_search(trie[letter], index + 1, word)
+            else:
+                return False
+
+    def search(self, word: str) -> bool:
+        # start the recursive search from index 0 and the root
+        return self.internal_search(self.trie, 0, word)

subtree-of-another-tree/yolophg.py

@@ -0,0 +1,36 @@
+# Time Complexity: O(m * n) m: number of nodes in root, n: number of nodes in subRoot, n: number of nodes in subRoot - might call the check function (which is O(n)) on every node in root.
+# Space Complexity: O(n) - use a queue for BFS that can hold up to O(n) nodes in the worst case.
+
+class Solution:
+    def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
+        if root is None:
+            return False 
+        if subRoot is None:
+            return True
+
+        # helper to compare two trees
+        def check(node1, node2):
+            if node1 is None and node2 is None:
+                return True 
+            if node1 is None or node2 is None:
+                return False 
+            if node1.val != node2.val:
+                return False 
+            # check left and right recursively
+            return check(node1.left, node2.left) and check(node1.right, node2.right)
+
+        # BFS through the main tree
+        queue = [root]
+        while queue:
+            curr = queue.pop(0)
+            # if value matches subRoot, check deeper
+            if curr.val == subRoot.val:
+                if check(curr, subRoot):
+                    return True
+            # add child nodes to keep exploring
+            if curr.left:
+                queue.append(curr.left)
+            if curr.right:
+                queue.append(curr.right)
+
+        return False

validate-binary-search-tree/yolophg.py

@@ -0,0 +1,21 @@
+# Time Complexity: O(n) - visit every node once during the inorder traversal
+# Space Complexity: O(n) - store all node values in an array during traversal
+
+class Solution:
+    def isValidBST(self, root: Optional[TreeNode]) -> bool:
+        # helper to do an inorder traversal and return a list of values
+        def inorder(node):
+            if not node:
+                return []
+            # in-order: left -> current -> right
+            return inorder(node.left) + [node.val] + inorder(node.right)
+
+        # get the in-order traversal of the tree
+        arr = inorder(root)
+
+        # if there are duplicates, it's not a valid BST
+        if len(arr) != len(set(arr)):
+            return False
+        
+        # if it's sorted in strictly increasing order, it's a valid BST
+        return arr == sorted(arr)