[dolphinflow86] WEEK 04 Solutions (#2741)

* merge two sorted lists solution

* maximum depth of binary tree solution

* find minimum in rotated sorted array solution

* word search solution

* Update maximum-depth-of-binary-tree/dolphinflow86.py

오 넵 이게 낫겠네요! 변수를 쓴다면 더 명시적으로 적어보겠습니다.

Co-authored-by: Hojeong Park <parkhj062@gmail.com>

* apply code review

* coin change solution

---------

Co-authored-by: Hojeong Park <parkhj062@gmail.com>

Author: dolphinflow86

coin-change/dolphinflow86.py

@@ -0,0 +1,19 @@
+# 1) Use top-down memoization, recursively calculate the minimum coins required for each remaining amount and cache the results to prune duplicated branches.
+# TC: O(K^M) where K is the number of coins, where M is the amount. We can recurse down at most M depth
+# SC: O(K + M)
+class Solution:
+    def dfs(self, coins: List[int], memo:Dict[int, int], remain: int):
+        if remain == 0: return 0
+        if remain < 0: return float('inf')
+        if remain in memo: return memo[remain]
+
+        min_result = float('inf')
+        for coin in coins:
+            min_result = min(min_result, self.dfs(coins, memo, remain - coin))
+
+        memo[remain] = min_result if min_result == float('inf') else min_result + 1
+        return memo[remain]
+
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        result = self.dfs(coins, {}, amount)
+        return result if result != float('inf') else -1

find-minimum-in-rotated-sorted-array/dolphinflow86.py

@@ -0,0 +1,20 @@
+# 1) Use binary search to halves to search range. Each iteration, 
+# compare with nums[pivot] and nums[right] to see which side has a smaller range. 
+# Firstly I compare nums[left] with nums[right] so I got the wrong results but end up with the right solution.
+# TC: O(logN) where N is the length of the nums array
+# SC: O(1)
+
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        n = len(nums)
+        left = 0
+        right = n-1
+
+        while left < right:
+            mid = left + (right - left) // 2
+            if nums[mid] < nums[right]:
+                right = mid
+            else:
+                left = mid + 1
+
+        return nums[right]

maximum-depth-of-binary-tree/dolphinflow86.py

@@ -0,0 +1,21 @@
+# 1) Use DFS to traverse down to the leaf node. Keep track of depth and return each node's maximum depth of each subtree to the parent node.
+# TC: O(N) where N is the number of node in the binary tree
+# SC: O(H) where H is the height of the binary tree
+# 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 dfs(self, node: Optional[TreeNode], depth: int) -> int:
+        if not node:
+            return depth
+
+        return max(
+            self.dfs(node.left, depth + 1),
+            self.dfs(node.right, depth + 1)
+        )
+
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        return self.dfs(root, 0)

merge-two-sorted-lists/dolphinflow86.py

@@ -0,0 +1,27 @@
+# 1) Use a dummy node and connect the smaller node to the merged list while iterating through both lists.
+# TC: O(N + M) where N is the length of list1 and M is the length of list2.
+# SC: O(1)
+#
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+        dummy = ListNode()
+        curr = dummy
+
+        while list1 and list2:
+            if list1.val < list2.val:
+                curr.next = list1
+                list1 = list1.next
+            else:
+                curr.next = list2
+                list2 = list2.next
+            curr = curr.next
+
+        curr.next = list1 if list1 else list2
+
+        return dummy.next

word-search/dolphinflow86.py

@@ -0,0 +1,42 @@
+# 1) Use dfs and backtracking to search for a word in the board.
+# TC: O(N*M*3^W) where N is len(row), M is len(col) and W is len(word)
+# SC: O(N*M) representing the maximum depth of the recursion tack.
+class Solution:
+    def dfs(self, board: List[List[str]], word: str, row: int, col: int, word_idx: int) -> bool:
+        if row < 0 or col < 0 or row >= len(board) or col >= len(board[0]):
+            return False
+        
+        if word_idx >= len(word) or board[row][col] != word[word_idx]:
+            return False
+
+        if word_idx == len(word) - 1:
+            return True
+        
+        temp = board[row][col]
+        board[row][col] = '#'
+
+        found = (
+            self.dfs(board, word, row + 1, col, word_idx + 1) or
+            self.dfs(board, word, row - 1, col, word_idx + 1) or
+            self.dfs(board, word, row, col + 1, word_idx + 1) or
+            self.dfs(board, word, row, col - 1, word_idx + 1)
+        )
+
+        board[row][col] = temp
+
+        return found
+
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        row_len = len(board)
+        column_len = len(board[0])
+        word_len = len(word)
+
+        # Early return if the board contains fewer cells than the word length.
+        if row_len * column_len < word_len: return False
+
+        for i in range(row_len):
+            for j in range(column_len):
+                if self.dfs(board, word, i, j, 0):
+                    return True
+
+        return False