Add solutions week 9

Author: sbk1014

clone-graph/bhyun-kim.py

@@ -0,0 +1,54 @@
+"""
+133. Clone Graph
+https://leetcode.com/problems/clone-graph/
+
+Solution:
+    To clone a graph, we can use a depth-first search (DFS) to explore all nodes and their neighbors.
+    We can create a helper function that takes a node and returns its clone.
+    
+    - We can use a dictionary to map old nodes to new nodes.
+    - We can create a helper function to clone a node and its neighbors.
+        - If the node has already been cloned, we return the clone.
+        - Otherwise, we create a new clone and add it to the dictionary.
+        - We clone all neighbors of the node recursively.
+        - We return the clone.
+    - We start the DFS from the given node and return the clone.
+
+Time complexity: O(n+m)
+    - n is the number of nodes in the graph.
+    - m is the number of edges in the graph.
+    - We explore all nodes and edges once.
+
+Space complexity: O(n)
+    - We use a dictionary to keep track of the mapping between old nodes and new nodes.
+    - The maximum depth of the recursive call stack is the number of nodes in the graph.
+"""
+
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+
+from typing import Optional
+
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if not node:
+            return None
+
+        old_to_new = {}
+
+        def dfs(node):
+            if node in old_to_new:
+                return old_to_new[node]
+
+            clone = Node(node.val)
+            old_to_new[node] = clone
+
+            for neighbor in node.neighbors:
+                clone.neighbors.append(dfs(neighbor))
+
+            return clone
+
+        return dfs(node)

course-schedule/bhyun-kim.py

@@ -0,0 +1,62 @@
+"""
+207. Course Schedule
+https://leetcode.com/problems/course-schedule/
+
+Solution: 
+    If there is a cycle in the graph, it is impossible to finish all courses.
+    We can detect a cycle by using DFS and keeping track of the state of each node.
+    
+    - We can create an adjacency list to represent the graph.
+    - We can use a state array to keep track of the state of each node.
+        - 0: unvisited, 1: visiting, 2: visited
+    - We can create a helper function to check if there is a cycle starting from a node.
+        - If the node is being visited, we have a cycle.
+        - If the node has been visited, there is no cycle.
+        - If not, we mark the node as visiting and explore its neighbors.
+        - After exploring all neighbors, we mark the node as visited.
+    - We can iterate through all nodes and check for cycles.
+    - If we find a cycle, we return False.
+    - If no cycle is found, we return True.
+
+Time complexity: O(m + n)
+    - m is the number of prerequisites.
+    - n is the number of courses.
+    - We explore all prerequisites and courses once.
+
+Space complexity: O(m + n)
+    - We use an adjacency list to represent the graph.
+    - We use a state array to keep track of the state of each node.
+"""
+
+from collections import defaultdict
+from typing import List
+
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        adj_list = defaultdict(list)
+        for dest, src in prerequisites:
+            adj_list[src].append(dest)
+
+        # State: 0 = unvisited, 1 = visiting, 2 = visited
+        state = [0] * numCourses
+
+        def has_cycle(v):
+            if state[v] == 1:  # Node is being visited, so we have a cycle
+                return True
+            if state[v] == 2:  # Node has been visited, no cycle here
+                return False
+            
+            state[v] = 1
+            for neighbor in adj_list[v]:
+                if has_cycle(neighbor):
+                    return True
+            
+            state[v] = 2
+            return False
+
+        for course in range(numCourses):
+            if state[course] == 0:
+                if has_cycle(course):
+                    return False
+        
+        return True

design-add-and-search-words-data-structure/bhyun-kim.py

@@ -0,0 +1,64 @@
+"""
+211. Design Add and Search Words Data Structure
+https://leetcode.com/problems/design-add-and-search-words-data-structure/
+
+Solution:
+    To solve this problem, we can use a trie data structure to store the words.
+    We can create a TrieNode class to represent each node in the trie.
+
+    In addWord, we can iterate through each character in the word and create nodes as needed.
+    We mark the end of the word by setting is_end_of_word to True.
+
+    In search, we can use a depth-first search (DFS) to explore all possible paths.
+    If we encounter a '.', we explore all children of the current node.
+    If we find a mismatch or reach the end of the word, we return False.
+
+
+Time complexity: 
+    - addWord: O(m)
+        - m is the length of the word.
+        - We iterate through each character in the word once.
+    - search: O(n * 26^l)
+        - n is the number of nodes in the trie.
+        - l is the length of the word.
+        - We explore all possible paths in the trie.
+        - The worst-case time complexity is O(n * 26^l) when all nodes have 26 children.
+
+Space complexity: O(n)
+    - n is the number of nodes in the trie.
+    - We use a trie data structure to store the words.
+"""
+
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.is_end_of_word = False
+
+class WordDictionary:
+    def __init__(self):
+        self.root = TrieNode()
+
+    def addWord(self, word):
+        node = self.root
+        for char in word:
+            if char not in node.children:
+                node.children[char] = TrieNode()
+            node = node.children[char]
+        node.is_end_of_word = True
+
+    def search(self, word):
+        def dfs(j, node):
+            for i in range(j, len(word)):
+                char = word[i]
+                if char == '.':
+                    for child in node.children.values():
+                        if dfs(i + 1, child):
+                            return True
+                    return False
+                else:
+                    if char not in node.children:
+                        return False
+                    node = node.children[char]
+            return node.is_end_of_word
+        
+        return dfs(0, self.root)