@@ -0,0 +1,46 @@
+class TrieNode:
+def __init__(self):
+self.children = {}
+self.is_word = False
+
+class Trie:
+
+def __init__(self):
+"""
+Initialize your data structure here.
+"""
+self.root = TrieNode()
+
+def insert(self, word: str) -> None:
+"""
+Inserts a word into the trie.
+"""
+cur_node = self.root
+for char in word:
+if char not in cur_node.children:
+cur_node.children[char] = TrieNode()
+cur_node = cur_node.children[char]
+cur_node.is_word = True
+
+def search(self, word: str) -> bool:
+"""
+Returns if the word is in the trie.
+"""
+cur_node = self.root
+for char in word:
+if char not in cur_node.children:
+return False
+cur_node = cur_node.children[char]
+return cur_node.is_word
+
+
+def startsWith(self, prefix: str) -> bool:
+"""
+Returns if there is any word in the trie that starts with the given prefix.
+"""
+cur_node = self.root
+for char in prefix:
+if char not in cur_node.children:
+return False
+cur_node = cur_node.children[char]
+return True

@@ -0,0 +1,32 @@
+class TrieNode:
+def __init__(self):
+self.child = {}
+self.value = 0
+
+class MapSum:
+
+def __init__(self):
+"""
+Initialize your data structure here.
+"""
+self.root = TrieNode()
+self.char_map = {}
+
+def insert(self, key: str, val: int) -> None:
+delta = val - self.char_map.get(key, 0)
+cur_node = self.root
+self.char_map[key] = val
+cur_node.value += delta
+for char in key:
+if char not in cur_node.child:
+cur_node.child[char] = TrieNode()
+cur_node = cur_node.child[char]
+cur_node.value += delta
+
+def sum(self, prefix: str) -> int:
+cur_node = self.root
+for char in prefix:
+if char not in cur_node.child:
+return 0
+cur_node = cur_node.child[char]
+return cur_node.value

@@ -0,0 +1,44 @@
+class TrieNode:
+def __init__(self):
+self.children = {}
+self.is_word = False
+self.word = ""
+
+class Trie:
+def __init__(self):
+self.root = TrieNode()
+
+def insertWord(self, word):
+cur = self.root
+for char in word:
+if char not in cur.children:
+cur.children[char] = TrieNode()
+cur = cur.children[char]
+cur.is_word = True
+cur.word = word
+
+def findWord(self, word):
+cur = self.root
+for char in word:
+if char in cur.children:
+cur = cur.children[char]
+if cur.is_word:
+return cur.word
+else:
+return ""
+return ""
+
+class Solution:
+def replaceWords(self, dictionary: List[str], sentence: str) -> str:
+trie = Trie()
+
+for word in dictionary:
+trie.insertWord(word)
+
+sentence = sentence.split(" ")
+
+for i in range(len(sentence)):
+root_word = trie.findWord(sentence[i])
+if root_word != "":
+sentence[i] = root_word
+return " ".join(sentence)

@@ -0,0 +1,39 @@
+class TrieNode:
+def __init__(self):
+self.children = {}
+self.is_word = False
+
+class WordDictionary:
+
+def __init__(self):
+"""
+Initialize your data structure here.
+"""
+self.root = TrieNode()
+
+def addWord(self, word: str) -> None:
+cur = self.root
+for char in word:
+if char not in cur.children:
+cur.children[char] = TrieNode()
+cur = cur.children[char]
+cur.is_word = True
+
+def search(self, word: str) -> bool:
+def searchRec(i, trie):
+if i == len(word):
+return trie.is_word
+
+# search all children if current char is "."
+if word[i] == ".":
+for val in trie.children.values():
+if searchRec(i + 1, val):
+return True
+return False
+
+if word[i] not in trie.children:
+return False
+
+return searchRec(i + 1, trie.children[word[i]])
+
+return searchRec(0, self.root)

@@ -0,0 +1,65 @@
+class Solution:
+def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
+if not board or not board[0] or not words: return []
+
+trie = Trie(words)
+
+self.result = set()
+for r in range(len(board)):
+for c in range(len(board[0])):
+self.dfs(r, c, trie.root, "", board)
+
+return list(self.result)
+
+def dfs(self, r, c, trie, s, board):
+if trie.is_word:
+self.result.add(s)
+trie.is_word = False
+
+if self.isValidPos(r, c, board):
+char = board[r][c]
+child_node = trie.children.get(char)
+if child_node is not None:
+s += char
+board[r][c] = None
+
+self.dfs(r + 1, c, child_node, s, board)
+self.dfs(r - 1, c, child_node, s, board)
+self.dfs(r, c + 1, child_node, s, board)
+self.dfs(r, c - 1, child_node, s, board)
+
+board[r][c] = char
+
+def isValidPos(self, r, c, board):
+if not 0 <= r < len(board):
+return False
+if not 0 <= c < len(board[0]):
+return False
+if board[r][c] is None:
+return False
+return True
+
+class TrieNode:
+def __init__(self):
+self.children = {}
+self.is_word = False
+
+class Trie:
+def __init__(self, words):
+"""
+Initialize your data structure here.
+"""
+self.root = TrieNode()
+for word in words:
+self.insert(word)
+
+def insert(self, word: str) -> None:
+"""
+Inserts a word into the trie.
+"""
+cur_node = self.root
+for char in word:
+if char not in cur_node.children:
+cur_node.children[char] = TrieNode()
+cur_node = cur_node.children[char]
+cur_node.is_word = True