[Leo] 8th Week solutions (last 2 Qs)

Author: leokim0922

implement-trie-prefix-tree/Leo.py

@@ -0,0 +1,42 @@
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.isEnd = False
+
+
+class Trie:
+    def __init__(self):
+        self.root = TrieNode()
+
+    def insert(self, word: str) -> None:
+        cur = self.root
+
+        for c in word:
+            if c not in cur.children:
+                cur.children[c] = TrieNode()
+            cur = cur.children[c]
+        cur.isEnd = True
+
+        ## TC: O(len(word)), SC: O(len(word))
+
+    def search(self, word: str) -> bool:
+        cur = self.root
+
+        for c in word:
+            if c not in cur.children:
+                return False
+            cur = cur.children[c]
+        return cur.isEnd
+
+        ## TC: O(len(word)), SC: O(1)
+
+    def startsWith(self, prefix: str) -> bool:
+        cur = self.root
+
+        for c in prefix:
+            if c not in cur.children:
+                return False
+            cur = cur.children[c]
+        return True
+
+        ## TC: O(len(prefix)). SC: O(1)

word-search/Leo.py

@@ -0,0 +1,30 @@
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        rows, cols = len(board), len(board[0])
+
+        def backtrack(r, c, index):
+            if index == len(word):
+                return True
+            if r < 0 or r >= rows or c < 0 or c >= cols or board[r][c] != word[index]:
+                return False
+
+            temp = board[r][c]
+            board[r][c] = "!"
+
+            found = (backtrack(r + 1, c, index + 1) or
+                     backtrack(r - 1, c, index + 1) or
+                     backtrack(r, c + 1, index + 1) or
+                     backtrack(r, c - 1, index + 1))
+
+            board[r][c] = temp
+            return found
+
+        for i in range(rows):
+            for j in range(cols):
+                if backtrack(i, j, 0):
+                    return True
+
+        return False
+
+        ## TC: O(D of row * D of Cols * 4^L), but amortised could be O(DoR * DoC)
+        ## SC: O(L)