Merge pull request #2475 from liza0525/main

[liza0525] WEEK 04 Solutions

Author: liza0525

coin-change/liza0525.py

@@ -0,0 +1,38 @@
+# 7기 풀이
+# 시간 복잡도: O(n * k)
+#  - 타겟 코인 값(amount, 복잡도 계산에선 n으로 표기)과 coins의 길이 만큼 탐색하며 계산
+# 공간 복잡도: O(n)
+#  - 타겟 코인 값(amount, 복잡도 계산에선 n으로 표기) 만큼의 min_coin_count 계산 array를 생성
+class Solution:
+    # 해당 문제는 현재 갖고 있는 돈으로 각 코인 값을 만드는 데에 동전을 얼마나 쓰는지 계산하여
+    # 그 조합 중 가장 작은 값을 계속 찾아가는 문제로, min_coin_count를 사용한다. 
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        min_coin_count = [-1 for _ in range(amount + 1)]  # 각 인덱스는 코인 값, value는 해당 코인 값을 만들 수 있는 동전의 개수(만들 수 없을 땐 -1)
+        min_coin_count[0] = 0  # 코인 값이 0일 때는 동전을 쓰지 않으면 되므로 무조건 0이 된다.
+
+        for target_amount in range(1, len(min_coin_count)):
+            # 각 코인 값에 대해 최소 동전 개수를 찾는다.
+            for coin in coins:
+                if target_amount - coin < 0:
+                    # 대상 코인 값보다 체크할 코인 값이 큰 경우에는 조합을 만들 수 없으므로 넘긴다
+                    continue
+                if min_coin_count[target_amount - coin] < 0:
+                    # target_amount - coin(보수)을 만들 수 없으면 target_amount도 만들 수 없음
+                    # 예시) target=5, coin=3 → 보수 2를 못 만들면 5도 못 만듦
+                    continue
+
+                # 위 두 가지 조건만 넘어가면 동전 개수를 min_coin_count[target_amount]에 정해서 넣을 수 있다는 의미
+                if min_coin_count[target_amount] == -1:
+                    # 값이 -1인 경우에는 처음으로 계산해서 넣는 것이기 때문에
+                    # min_coin_count[target_amount - coin]에다가 1을 더해서(coin 한 개를 추가 한다는 의미) min_coin_count[target_amount]에 할당
+                    min_coin_count[target_amount] = min_coin_count[target_amount - coin] + 1
+                else:
+                    # 값이 -1이 아닌 경우는 이전에 저장된 동전 개수가 있으므로
+                    # 이전 결과 값과 min_coin_count[target_amount - coin] + 1의 값을 비교하여 더 적은 수를 저장한다.
+                    min_coin_count[target_amount] = min(
+                        min_coin_count[target_amount],
+                        min_coin_count[target_amount - coin] + 1
+                    )
+
+        # 모두 계산한 후 min_coin_count[amount]를 반환한다. (== amount를 만드는 동전의 최소 개수)
+        return min_coin_count[amount]

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

@@ -36,3 +36,25 @@ def find_max_depth(cur_node, depth):
         max_depth = find_max_depth(root, 0)
 
         return max_depth
+
+
+# 7기 풀이
+# 시간복잡도: O(n)
+#  - 트리의 모든 노드를 한 번 씩 방문하므로, 전체 노드 수 n만큼 시간이 걸림
+# 공간복잡도: O(n)
+#  - 트리의 높이만큼 재귀 스택이 쌓임. 최악의 경우는 트리가 한 쪽으로 치우쳤을 때이므로 노드 n만큼의 최대 스택을 쌓게 됨
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        def find_depth(node, depth):
+            if not node:
+                # node가 None일 때는 depth을 그대로 반환
+                return depth
+            # 현재 노드 기준 왼쪽 노드 쪽의 깊이 탐색
+            left_depth = find_depth(node.left, depth + 1)
+            # 현재 노드 기준 오른쪽 노드 쪽의 깊이 탐색
+            right_depth = find_depth(node.right, depth + 1)
+
+            # 왼쪽과 오른쪽 중 더 깊은 depth를 반환
+            return max(left_depth, right_depth)
+
+        return find_depth(root, 0)

merge-two-sorted-lists/liza0525.py

@@ -41,3 +41,40 @@ def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) ->
 
         # dummy 노드 다음부터가 실제 머지된 리스트의 시작점
         return root_node.next
+
+
+# 7기 풀이
+# 시간 복잡도: O(n + m)
+#   - list1의 길이 n, list2의 길이 m의 개수를 번갈아가며 탐색할 때 최악
+# 공간 복잡도: O(1)
+#   - dummy 노드와 curr 만 사용하므로 추가 공간 없음
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+        dummy = ListNode()  # dummy node를 만들어 dummy.next부터 리스트들을 머지하도록 한다.
+        curr = dummy  # curr 포인트를 dummy에 둔다
+
+        # list1과 list2 모두가 있을 때 루프를 돈다.
+        # 둘 중 하나라도 None이 되는 순간 루프 탈출
+        while list1 and list2:
+            if list1.val < list2.val:
+                # list1의 숫자가 더 작을 땐 curr.next에 list1의 헤드를 넣고,
+                # 포인터를 next node로 옮김
+                curr.next = list1
+                list1 = list1.next
+            else:
+                # list2의 숫자가 더 작을 땐 curr.next에 list2의 헤드를 넣고,
+                # 포인터를 next node로 옮김
+                curr.next = list2
+                list2 = list2.next
+            
+            # 다음 노드 merge를 위해 curr도 포인터를 next로 변경
+            curr = curr.next
+        
+        # 루프 탈출 후 남아 있는 리스트가 있다면 curr의 next에 남은 리스트를 머지한다.
+        if list1:
+            curr.next = list1
+        elif list2:
+            curr.next = list2
+
+        # dummy 노드는 예비용, dummy.next를 리턴
+        return dummy.next

search-in-rotated-sorted-array/liza0525.py

@@ -0,0 +1,30 @@
+# 7기 풀이
+# 시간 복잡도: O(log n)
+#  - binary search를 이용했기 때문에 최악의 경우는 log n
+# 공간 복잡도: O(1)
+#  - 몇 가지 변수만 사용됨
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        # 양 끝을 먼저 잡아준다
+        left, right = 0, len(nums) - 1
+
+        # left보다 right가 클 때 계속 루프를 돈다
+        # 이는 left와 right가 같아질 때까지 돈다는 말과 동일하다
+        while left < right:
+            # 중간 index 계산
+            mid = (left + right) // 2
+
+            if nums[mid] > nums[right]:
+                # 중간 index의 값이 오른쪽 index의 값보다 크다는 것은
+                # 최소 값이 mid 기준 오른쪽 구역에 존재하기 때문에 left을 mid쪽으로 움직인다.
+                # mid의 값 자체는 최소값이 될 수 없기 때문에 left는 이보다 한 칸 옆으로 움직여야 함
+                left = mid + 1
+            else:
+                # 중간 index의 값이 오른쪽 index의 값보다 작다는 것은
+                # 최소 값이 mid 기준 왼쪽 구역에 존재하기 때문에 right를 mid쪽으로 움직인다.
+                # mid의 값 자체는 최소값이 될 수 있기 때문에 right는 mid 값을 할당한다.
+                right = mid
+
+        # left와 right가 같아질 때(최소값을 찾았을 때) 루프 탈출을 하기 때문에
+        # nums[left] 또는 nums[right]를 반환 
+        return nums[left]

word-search/liza0525.py

@@ -65,3 +65,73 @@ def dfs(i, j, str_index):
 
         # 모든 시도를 해도 못 찾으면 False
         return False
+
+
+# 7기 풀이
+# 시간 복잡도: O((n * m) * 4 ^ d)
+#  - depth의 길이(d)만큼 네 방향을 탐색하며, 출발점의 개수 n * m 모두 탐색할 때 최악의 시간
+# 공간 복잡도: O(n * m)
+#  - visited 변수를 사용하기 때문에 행 * 열의 개수만큼의 공간을 필요로 함
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        # 보드의 행, 열의 길이를 미리 저장
+        num_rows = len(board)
+        num_cols = len(board[0])
+
+        # dfs 탐색 시 이미 방문한 경우를 체크하기 위한 visited를 생성
+        visited = [[0 for _ in range(num_cols)] for _ in range(num_rows)]
+
+        # dfs 탐색 시 한 칸을 기준으로 하여 4방향으로 탐색 가능하게 directions을 만든다.
+        # 순서대로 아래로 진출, 위로 진출, 왼쪽으로 진출, 오른쪽으로 진출
+        directions = [(0, 1), (0, -1), (-1, 0), (1, 0)]
+
+        def check_exist_word(i, j, depth):
+            if depth == len(word) - 1:
+                # depth가 word의 길이에 가까워지면(배열이라 -1 해줌)
+                # 탐색을 마쳤으므로 True를 반환
+                return True
+
+            # 현재의 칸은 방문했다는 의미로 1로 변경
+            visited[i][j] = 1
+            for dir_i, dir_j in directions:
+                # 네 방향을 순차로 탐색한다.
+                # 다음 칸의 위치를 나타내는 next_i와 next_j를 먼저 계산
+                next_i, next_j = i + dir_i, j + dir_j
+                if not (
+                    0 <= next_i < num_rows  # 다음 칸의 행 번호가 행의 길이 내에 있고
+                    and 0 <= next_j < num_cols  # 다음 칸의 열 번호가 열의 길이 내에 있고
+                    and not visited[next_i][next_j]  # 아직 방문하지 않았으며
+                    and board[next_i][next_j] == word[depth + 1]  # 다음 글자가 word의 다음 글자에 해당해야 함
+                ):
+                    # 그렇지 않은 경우에는 탐색할 필요가 없으므로 다음 방향을 찾는다
+                    continue
+                
+                # 위의 조건을 모두 만족하면 탐색해도 된다.
+                exist_word = check_exist_word(
+                    next_i,
+                    next_j,
+                    depth + 1  # word의 다음 index를 찾아야 함
+                )
+                if exist_word:
+                    # 단어를 찾았다고 하면 early return
+                    return True
+                
+            # 백트래킹을 위해 현재 칸의 visited 값을 원복한다.
+            visited[i][j] = 0
+
+            # 단어를 찾지 못했을 땐 False 반환
+            return False
+
+        for i in range(num_rows):
+            for j in range(num_cols):
+                if board[i][j] != word[0]:
+                    # 출발 글자가 word의 첫 글자랑 같지 않으면 탐색할 필요가 없으므로 넘긴다.
+                    continue
+
+                exist_word = check_exist_word(i, j, 0)
+                if exist_word:
+                    # 단어를 찾았으면 탐색을 더이상 하지 않아도 되므로 early return
+                    return True
+
+        # 보드의 모든 탐색을 해도 찾지 못한 경우에는 False 반환
+        return False