Merge pull request #2478 from sangbeenmoon/main

[sangbeenmoon] WEEK 04 Solutions

Author: sangbeenmoon

coin-change/sangbeenmoon.py

@@ -0,0 +1,32 @@
+# dp[i] = min(dp[i - c0], dp[i - c1], ... , dp[i - cn]) + 1
+
+# TC : O(amount * len(coins))
+# SC : O(amount)
+
+class Solution:
+    dp = []
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        self.dp = [-2] * (amount + 10)  # 아직 방문하지 않음 -> -2
+        
+        return self.go(amount, coins)
+        
+        
+    def go(self, x: int, coins: List[int]) -> int:
+        if x == 0:
+            return 0
+
+        if self.dp[x] != -2:
+            return self.dp[x]
+        
+        mm = 100000
+
+        for coin in coins:
+            if x - coin >= 0:
+                sub = self.go(x - coin, coins)
+                if (sub == -1): # 불가능 -> -1
+                    continue
+                mm = min(mm, sub + 1)
+        
+        self.dp[x] = mm if mm != 100000 else -1 # memoization
+            
+        return self.dp[x]

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

@@ -0,0 +1,22 @@
+# TC : O(logN)
+# SC : 1
+
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        
+        left = 0
+        right = len(nums) - 1
+        mid = (left + right) // 2
+
+        if len(nums) == 2:
+            return min(nums)
+        
+        while left < right:
+            mid = (left + right) // 2
+            
+            if nums[mid] >= nums[right]:
+                left = mid + 1
+            else:
+                right = mid
+            
+        return nums[left]

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

@@ -0,0 +1,27 @@
+# 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
+
+# TC : O(n)
+# SC : O(n)
+
+class Solution:
+    answer = 0
+
+    def go(self, cur: TreeNode, depth:int):
+        self.answer = max(self.answer, depth)
+        if cur.left != None:
+            self.go(cur.left, depth + 1)
+        if cur.right != None:
+            self.go(cur.right, depth + 1)
+
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        self.answer = 0
+        
+        if root != None:
+            self.go(root, 1)
+
+        return self.answer

merge-two-sorted-lists/sangbeenmoon.py

@@ -0,0 +1,35 @@
+# 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]:
+        
+        cur1 = list1
+        cur2 = list2
+
+        answer = ListNode()
+        head = answer
+
+
+        while cur1 != None:
+            if cur2 != None:
+                if cur1.val >= cur2.val:
+                    answer.next = ListNode(cur2.val)
+                    cur2 = cur2.next
+                    answer = answer.next
+                else:
+                    answer.next = ListNode(cur1.val)
+                    cur1 = cur1.next
+                    answer = answer.next
+            else:
+                answer.next = ListNode(cur1.val)
+                cur1 = cur1.next
+                answer = answer.next
+        
+        while cur2 != None:
+            answer.next = ListNode(cur2.val)
+            cur2 = cur2.next
+            answer = answer.next
+        return head.next

word-search/sangbeenmoon.py

@@ -0,0 +1,36 @@
+# TC : O(m * n * 4^L)
+# SC : O(m * n + L)
+
+class Solution:
+    answer = False
+    dx = [0,0,-1,1]
+    dy = [-1,1,0,0]
+
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        
+        for yy in range(len(board)):
+            for xx in range(len(board[0])):
+                if board[yy][xx] == word[0]:
+                    self.visited = [ [False] * len(board[0]) for _ in range(len(board))]
+                    self.visited[yy][xx] = True
+                    self.dfs(board, word, xx, yy, 0)
+                    
+
+        return self.answer
+
+    def dfs(self, board, word, cx, cy, idx):
+        print(cx, cy, idx)
+        if idx == len(word) - 1:
+            self.answer = True
+
+        for i in range(4):
+            nx = cx + self.dx[i]
+            ny = cy + self.dy[i]
+
+            if 0 <= nx and nx < len(board[0]):
+                if 0 <= ny and ny < len(board):
+                    if self.visited[ny][nx] == False:
+                        if idx + 1 <= len(word) - 1 and word[idx+1] == board[ny][nx]:
+                            self.visited[ny][nx] = True
+                            self.dfs(board, word, nx, ny, idx + 1)
+                            self.visited[ny][nx] = False