Add solution of combination-sum and formatting

Author: sbk1014

combination-sum/bhyun-kim.py

@@ -0,0 +1,49 @@
+"""
+39. Combination Sum
+https://leetcode.com/problems/combination-sum/
+
+Solution
+    To solve this problem, we can use backtracking.
+    The idea is to explore all possible combinations starting from each candidate.
+    
+    - We can sort the candidates to avoid duplicates.
+    - We can create a helper function that takes the remaining target, the current combination, and the start index.
+    - If the remaining target is 0, we have found a valid combination, so we add it to the result.
+    - If the remaining target is negative, we return.
+    - We iterate through the candidates starting from the start index.
+    - We add the current candidate to the combination and recursively call the helper function with the updated target and combination.
+    - After the recursive call, we remove the current candidate from the combination.
+
+Time complexity: O(2^n)
+    - In the worst case, we explore all possible combinations.
+    - For each candidate, we have two choices: include it or exclude it.
+
+Space complexity: O(n)
+    - The recursive call stack has a maximum depth of n.
+"""
+
+from typing import List
+
+
+class Solution:
+    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+        def backtrack(remain, comb, start):
+            if remain == 0:
+                result.append(list(comb))
+                return
+            elif remain < 0:
+                return
+
+            for i in range(start, len(candidates)):
+                current_candidate = candidates[i]
+                if current_candidate > remain:
+                    break
+
+                comb.append(current_candidate)
+                backtrack(remain - current_candidate, comb, i)
+                comb.pop()
+
+        candidates.sort()
+        result = []
+        backtrack(target, [], 0)
+        return result

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

@@ -5,13 +5,15 @@
 
 from typing import List, Optional
 
+
 # Definition for a binary tree node.
 class TreeNode:
     def __init__(self, val=0, left=None, right=None):
         self.val = val
         self.left = left
         self.right = right
 
+
 """
 Solution
     To solve this problem, we can use a recursive approach. 
@@ -37,6 +39,7 @@ def __init__(self, val=0, left=None, right=None):
     - The recursive call stack has n elements.
 """
 
+
 class Solution:
     def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
         inorder_index_map = {val: idx for idx, val in enumerate(inorder)}
@@ -57,4 +60,4 @@ def array_to_tree(left, right):
 
             return root
 
-        return array_to_tree(0, len(inorder) - 1)
+        return array_to_tree(0, len(inorder) - 1)

implement-trie-prefix-tree/bhyun-kim.py

@@ -20,14 +20,14 @@
     - The list of words may have all the words in the trie.
 """
 
-class Trie:
 
+class Trie:
     def __init__(self):
         self.words = []
 
     def insert(self, word: str) -> None:
         self.words.append(word)
-        
+
     def search(self, word: str) -> bool:
         return word in self.words
 
@@ -36,12 +36,11 @@ def startsWith(self, prefix: str) -> bool:
             if word.startswith(prefix):
                 return True
 
-        return False 
-        
+        return False
 
 
 # Your Trie object will be instantiated and called as such:
 # obj = Trie()
 # obj.insert(word)
 # param_2 = obj.search(word)
-# param_3 = obj.startsWith(prefix)
+# param_3 = obj.startsWith(prefix)

kth-smallest-element-in-a-bst/bhyun-kim.py

@@ -18,21 +18,23 @@
 
 from typing import Optional
 
+
 # Definition for a binary tree node.
 class TreeNode:
     def __init__(self, val=0, left=None, right=None):
         self.val = val
         self.left = left
         self.right = right
 
+
 class Solution:
     def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
-        return self.inOrderSearch(root)[k-1]
+        return self.inOrderSearch(root)[k - 1]
 
     def inOrderSearch(self, root):
         output = []
-        if root: 
+        if root:
             output += self.inOrderSearch(root.left)
             output += [root.val]
             output += self.inOrderSearch(root.right)
-        return output
+        return output

validate-binary-search-tree/bhyun-kim.py

@@ -43,15 +43,12 @@ def isValidBST(self, root: Optional[TreeNode]) -> bool:
         return self.isValidSubTree(root, maximum, minimum)
 
     def isValidSubTree(self, root, maximum, minimum):
-
         if root is None:
             return True
 
-        if not minimum < root.val < maximum: 
-            return False 
-        
+        if not minimum < root.val < maximum:
+            return False
+
         return self.isValidSubTree(
             root.left, root.val, minimum
-            ) and self.isValidSubTree(
-            root.right, maximum, root.val 
-            )
+        ) and self.isValidSubTree(root.right, maximum, root.val)

word-search/bhyun-kim.py

@@ -37,13 +37,14 @@
 
 from typing import List
 
+
 class Solution:
     def exist(self, board: List[List[str]], word: str) -> bool:
         if not board or not word:
             return False
 
         m, n = len(board), len(board[0])
-        
+
         # Step 1: Check if all characters in the word exist in the board
         char_count = {}
         for row in board:
@@ -62,18 +63,20 @@ def exist(self, board: List[List[str]], word: str) -> bool:
         def dfs(i, j, word_index):
             if word_index == len(word):
                 return True
-            
+
             if i < 0 or i >= m or j < 0 or j >= n or board[i][j] != word[word_index]:
                 return False
 
             temp = board[i][j]
             board[i][j] = "#"  # mark as visited
 
             # Explore all possible directions
-            found = (dfs(i + 1, j, word_index + 1) or
-                    dfs(i - 1, j, word_index + 1) or
-                    dfs(i, j + 1, word_index + 1) or
-                    dfs(i, j - 1, word_index + 1))
+            found = (
+                dfs(i + 1, j, word_index + 1)
+                or dfs(i - 1, j, word_index + 1)
+                or dfs(i, j + 1, word_index + 1)
+                or dfs(i, j - 1, word_index + 1)
+            )
 
             board[i][j] = temp  # unmark
             return found
@@ -84,4 +87,4 @@ def dfs(i, j, word_index):
                 if board[i][j] == word[0] and dfs(i, j, 0):
                     return True
 
-        return False
+        return False