Merge pull request DaleStudy#141 from SamTheKorean/solution8

[SAM] Week 8 solutions

Author: SamTheKorean

combination-sum/samthekorean.py

@@ -0,0 +1,19 @@
+# TC : O(n^2)
+# SC : O(n)
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        result = []
+
+        def dfs(start: int, total: int, current_combination: List[int]):
+            if total > target:
+                return
+            if total == target:
+                result.append(current_combination[:])
+                return
+            for i in range(start, len(candidates)):
+                current_combination.append(candidates[i])
+                dfs(i, total + candidates[i], current_combination)
+                current_combination.pop()
+
+        dfs(0, 0, [])
+        return result

construct-binary-tree-from-preorder-and-inorder-traversal/samthekorean.py

@@ -0,0 +1,12 @@
+# TC : O(n)
+# SC : O(n)
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        if not preorder or not inorder:
+            return None
+
+        root = TreeNode(preorder[0])
+        mid = inorder.index(preorder[0])
+        root.left = self.buildTree(preorder[1 : mid + 1], inorder[:mid])
+        root.right = self.buildTree(preorder[mid + 1 :], inorder[mid + 1 :])
+        return root

implement-trie-prefix-tree/samthekorean.py

@@ -0,0 +1,21 @@
+# TC : O(n)
+# SC : O(n)
+class Solution:
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        n = 0
+        stack = []
+        cur = root
+
+        while cur or stack:
+            while cur:
+                stack.append(cur)
+                cur = cur.left
+
+            cur = stack.pop()
+            n += 1
+            if n == k:
+                return cur.val
+
+            cur = cur.right
+
+        return -1

kth-smallest-element-in-a-bst/samthekorean.py

@@ -0,0 +1,40 @@
+# TC : O(N * 4^L), where N is the number of cells in the board and L is the length of the word.
+# SC : O(L) due to the recursive calls in the backtrack function, where L is the length of the word.
+class Solution:
+    def exist(self, board, word):
+        def backtrack(i, j, k):
+            # If we have checked all characters in the word
+            if k == len(word):
+                return True
+            # If out of bounds or current cell does not match the word character
+            if (
+                i < 0
+                or i >= len(board)
+                or j < 0
+                or j >= len(board[0])
+                or board[i][j] != word[k]
+            ):
+                return False
+
+            # Temporarily mark the cell as visited
+            temp = board[i][j]
+            board[i][j] = ""
+
+            # Explore all possible directions: down, up, right, left
+            found = (
+                backtrack(i + 1, j, k + 1)
+                or backtrack(i - 1, j, k + 1)
+                or backtrack(i, j + 1, k + 1)
+                or backtrack(i, j - 1, k + 1)
+            )
+
+            # Restore the original value of the cell
+            board[i][j] = temp
+            return found
+
+        # Start from each cell in the board
+        for i in range(len(board)):
+            for j in range(len(board[0])):
+                if backtrack(i, j, 0):
+                    return True
+        return False