[freemjstudio] WEEK 04 Solutions (#2752)

* merged-two-sorted-lists

* maximum-depth-of-binary-tree/freemjstudio.py

* coin change

* add: coin change solution by freemjstudio

* find-minimum-in-rotated-sorted-array

* word-search

Author: freemjstudio

coin-change/freemjstudio.py

@@ -0,0 +1,22 @@
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        if amount == 0:
+            return 0
+        INF = int(1e9)
+        # dp[n] 은 n 원을 만들기 위한 최소한의 동전 개수를 저장한다.
+        dp = [INF] * (amount + 1)
+        usable_coins = []
+        for coin in coins:
+            if coin == amount:
+                return 1
+            if coin < amount:
+                dp[coin] = 1 # dp[3] = 1
+                usable_coins.append(coin)
+
+        # dp 를 채워나가는 과정
+        for i in range(1, amount+1):
+            for coin in usable_coins:
+                if (i - coin) >= 0 and dp[i - coin] != INF:
+                    dp[i] = min(dp[i - coin] + 1, dp[i])
+
+        return -1 if dp[amount] == INF else dp[amount]

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

@@ -0,0 +1,19 @@
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        min_value = 5000
+        # O(log n) 이므로 binary search
+        if len(nums) == 1:
+            return nums[0]
+        left = 0
+        right = len(nums) - 1
+
+        while left <= right:
+            mid = (left + right) // 2
+            min_value = min(nums[mid], min_value)
+
+            if nums[mid] > nums[right]:
+                left = mid + 1
+            else:
+                right = mid - 1
+
+        return min_value

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

@@ -0,0 +1,14 @@
+# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
+        if root is None:
+            return 0
+
+        left = self.maxDepth(root.left)
+        right = self.maxDepth(root.right)
+        return max(left, right) + 1

merge-two-sorted-lists/freemjstudio.py

@@ -0,0 +1,24 @@
+# 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()
+        merged_list = dummy
+
+        while list1 is not None and list2 is not None:
+            if list1.val <= list2.val:
+                merged_list.next = list1
+                list1 = list1.next
+            else:
+                merged_list.next = list2
+                list2 = list2.next
+            # merged_list 포인터를 한칸 이동시켜서 다음 노드 붙일 준비
+            merged_list = merged_list.next
+
+        # 남아 있는 노드 붙이기
+        merged_list.next = list1 if list1 is not None else list2
+
+        return dummy.next

word-search/freemjstudio.py

@@ -0,0 +1,39 @@
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        answer = False
+
+        dx = [-1, 1, 0, 0]
+        dy = [0, 0, -1, 1]
+        n = len(board)
+        m = len(board[0])
+        visited = [[False] * m for _ in range(n)]
+
+        def dfs(x, y, visited, route):
+            nonlocal answer
+            if route == word:
+                answer = True
+                return
+            if (len(route) == len(word)) and route != word:
+                return
+
+            for i in range(4):
+                nx = x + dx[i]
+                ny = y + dy[i]
+
+                if 0 <= nx < n and 0 <= ny < m and not visited[nx][ny]:
+                    idx = len(route)
+                    if word[idx] == board[nx][ny]:
+                        visited[nx][ny] = True
+                        route += board[nx][ny]
+                        dfs(nx, ny, visited, route)
+                        visited[nx][ny] = False
+                        route = route[:-1]
+
+        for i in range(n):
+            for j in range(m):
+                if board[i][j] == word[0]:
+                    visited[i][j] = True
+                    dfs(i, j, visited, word[0])
+                    visited[i][j] = False
+
+        return answer