week 4

week 4

Author: taurus09318976

coin-change/taurus09318976.py

@@ -0,0 +1,46 @@
+'''
+이 문제는 동적 프로그래밍을 이용한 방식이
+1) 모든 가능한 경우를 체계적으로 계산할 수 있고,
+2) 중복 계산을 피할 수 있고,
+3) 최적의 값을 보장한다는 점에서 좋은 풀이방식임.
+다만, 
+1) amount가 클 경우 메모리 사용이 많을 수 있고,
+2) 동전의 가치가 매우 작을 경우 시간이 오래 걸릴 수 있다는 점에서 단점이 있음
+'''
+
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        # 초기화
+        # dp 배열: 각 금액을 만들기 위한 최소 동전 수를 저장
+        # amount + 1로 초기화 (불가능한 경우를 구분하기 위해)
+        # 0원을 만들기 위한 동전 수는 0
+        dp = [amount + 1] * (amount + 1)
+        dp[0] = 0
+        
+        # 동적 프로그래밍 실행:
+        # 1원부터 amount원까지 순차적으로 계산
+        for i in range(1, amount + 1):
+            # 각 동전에 대해 시도
+            for coin in coins:
+                # 현재 금액이 동전보다 크거나 같은 경우에만 시도
+                if i >= coin:
+                    # 현재 동전을 사용하는 경우와 사용하지 않는 경우 중 최소값 선택
+                    dp[i] = min(dp[i], dp[i - coin] + 1)
+        
+        # 결과 반환
+        # amount원을 만들 수 없는 경우 -1 반환
+        return dp[amount] if dp[amount] != amount + 1 else -1
+
+        # 시간 복잡도 (Time Complexity): O(n * m)
+            #n: amount
+            #m: coins의 길이
+            #이유:
+                #amount까지의 모든 금액에 대해 계산
+                #각 금액마다 모든 동전을 확인
+                #따라서 시간 복잡도는 O(n * m)
+        # 공간 복잡도 (Space Complexity): O(n)
+            # n: amount
+            #이유:
+                # dp 배열의 크기가 amount + 1
+                # 추가적인 메모리 사용 없음
+                # 따라서 공간 복잡도는 O(n) 

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

@@ -0,0 +1,75 @@
+# 백트래킹 방법을 사용하여 풀이함
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        # 보드의 행과 열 수
+        rows, cols = len(board), len(board[0])
+        # 방문한 셀을 추적하는 집합
+        visited = set()
+        
+        # 깊이우선 탐색(DFS) 함수 정의
+        #r, c은 현재 셀의 행과 열, i는 현재 찾고 있는 단어의 인덱스
+        def dfs(r, c, i):
+            #기본 조건 확인
+            # 단어의 모든 문자를 찾은 경우 성공
+            if i == len(word):
+                return True
+            
+            #윺효성 검사
+            # 범위를 벗어나거나 이미 방문했거나 현재 셀의 문자가 단어의 현재 문자와 일치하지 않는 경우
+            if (r < 0 or c < 0 or 
+                r >= rows or c >= cols or 
+                (r, c) in visited or 
+                board[r][c] != word[i]):
+                return False
+            
+            # 현재 셀을 방문했다고 표시
+            visited.add((r, c))
+            
+            # 상하좌우 방향으로 탐색
+            result = (dfs(r + 1, c, i + 1) or  # 아래
+                     dfs(r - 1, c, i + 1) or  # 위
+                     dfs(r, c + 1, i + 1) or  # 오른쪽
+                     dfs(r, c - 1, i + 1))    # 왼쪽
+            
+            # 백트래킹: 현재 셀을 방문하지 않은 것으로 표시
+            #현재 경로가 실패했으므로 방문 표시 제거
+            visited.remove((r, c))
+            
+            return result
+        
+        # 보드의 모든 셀에서 시작점으로 시도
+        for r in range(rows):
+            for c in range(cols):
+                if dfs(r, c, 0):
+                    return True
+        
+        return False
+
+        #시간 복잡도 (Time Complexity): O(m * n * 4^L)
+            #m: 보드의 행 수
+            #n: 보드의 열 수
+            #L: 단어의 길이
+            #이유:
+                #각 셀에서 시작할 수 있음: O(m * n)
+                #각 위치에서 4방향으로 탐색 가능: O(4^L)
+                #최악의 경우 모든 경로를 탐색해야 함
+                #따라서 시간 복잡도는 O(m * n * 4^L)
+        #공간 복잡도 (Space Complexity): O(L)
+            #L: 단어의 길이
+            #이유:
+                #재귀 호출 스택의 깊이는 단어의 길이에 비례
+                #visited 집합의 크기도 단어의 길이에 비례
+                #따라서 공간 복잡도는 O(L)
+        #DFS vs BFS 비교:
+            #DFS (깊이 우선 탐색):
+            #한 경로를 끝까지 탐색
+            #스택/재귀 사용
+            #메모리 사용이 적음
+            #최단 경로 보장하지 않음
+        #BFS (너비 우선 탐색):
+            #같은 레벨의 모든 노드를 먼저 탐색
+            #큐 사용
+            #메모리 사용이 많음
+            #최단 경로 보장
+
+

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

@@ -0,0 +1,58 @@
+# 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: TreeNode) -> int:
+        # 루트가 None이면 깊이는 0
+        if not root:
+            return 0
+        
+        # 왼쪽 서브트리와 오른쪽 서브트리의 최대 깊이를 재귀적으로 계산
+        left_depth = self.maxDepth(root.left)
+        right_depth = self.maxDepth(root.right)
+        
+        # 현재 노드의 깊이(1) + 왼쪽과 오른쪽 중 더 큰 깊이
+        return 1 + max(left_depth, right_depth)
+
+# 테스트 코드
+def create_binary_tree(lst):
+    if not lst:
+        return None
+    
+    root = TreeNode(lst[0])
+    queue = [root]
+    i = 1
+    
+    while queue and i < len(lst):
+        current = queue.pop(0)
+        
+        if lst[i] is not None:
+            current.left = TreeNode(lst[i])
+            queue.append(current.left)
+        i += 1
+        
+        if i < len(lst) and lst[i] is not None:
+            current.right = TreeNode(lst[i])
+            queue.append(current.right)
+        i += 1
+    
+    return root
+
+# 테스트 케이스
+solution = Solution()
+
+# 테스트 케이스 1: [3,9,20,None,None,15,7]
+tree1 = create_binary_tree([3,9,20,None,None,15,7])
+print(solution.maxDepth(tree1))  # 3 출력
+
+# 테스트 케이스 2: [1,None,2]
+tree2 = create_binary_tree([1,None,2])
+print(solution.maxDepth(tree2))  # 2 출력
+
+# 테스트 케이스 3: []
+tree3 = create_binary_tree([])
+print(solution.maxDepth(tree3))  # 0 출력 

merge-two-sorted-lists/taurus09318976.py

@@ -0,0 +1,68 @@
+# 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: ListNode, list2: ListNode) -> ListNode:
+        # 더미 노드 생성
+        dummy = ListNode()
+        current = dummy
+        
+        # 두 리스트가 모두 존재하는 동안 반복
+        while list1 and list2:
+            if list1.val <= list2.val:
+                current.next = list1
+                list1 = list1.next
+            else:
+                current.next = list2
+                list2 = list2.next
+            current = current.next
+        
+        # 남은 노드들 연결
+        if list1:
+            current.next = list1
+        else:
+            current.next = list2
+            
+        return dummy.next
+
+# 테스트 코드
+def create_linked_list(lst):
+    if not lst:
+        return None
+    head = ListNode(lst[0])
+    current = head
+    for val in lst[1:]:
+        current.next = ListNode(val)
+        current = current.next
+    return head
+
+def linked_list_to_list(head):
+    result = []
+    while head:
+        result.append(head.val)
+        head = head.next
+    return result
+
+# 테스트 케이스
+solution = Solution()
+
+# 테스트 케이스 1
+list1 = create_linked_list([1,2,4])
+list2 = create_linked_list([1,3,4])
+result = solution.mergeTwoLists(list1, list2)
+print(linked_list_to_list(result))  # [1,1,2,3,4,4]
+
+# 테스트 케이스 2
+list1 = create_linked_list([])
+list2 = create_linked_list([])
+result = solution.mergeTwoLists(list1, list2)
+print(linked_list_to_list(result))  # []
+
+# 테스트 케이스 3
+list1 = create_linked_list([])
+list2 = create_linked_list([0])
+result = solution.mergeTwoLists(list1, list2)
+print(linked_list_to_list(result))  # [0]

word-search/taurus09318976.py

@@ -0,0 +1,62 @@
+# 백트래킹 방법을 사용하여 풀이함
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        # 보드의 행과 열 수
+        rows, cols = len(board), len(board[0])
+        # 방문한 셀을 추적하는 집합
+        visited = set()
+        
+        # 깊이우선 탐색(DFS) 함수 정의
+        #r, c은 현재 셀의 행과 열, i는 현재 찾고 있는 단어의 인덱스
+        def dfs(r, c, i):
+            #기본 조건 확인
+            # 단어의 모든 문자를 찾은 경우 성공
+            if i == len(word):
+                return True
+            
+            #윺효성 검사
+            # 범위를 벗어나거나 이미 방문했거나 현재 셀의 문자가 단어의 현재 문자와 일치하지 않는 경우
+            if (r < 0 or c < 0 or 
+                r >= rows or c >= cols or 
+                (r, c) in visited or 
+                board[r][c] != word[i]):
+                return False
+            
+            # 현재 셀을 방문했다고 표시
+            visited.add((r, c))
+            
+            # 상하좌우 방향으로 탐색
+            result = (dfs(r + 1, c, i + 1) or  # 아래
+                     dfs(r - 1, c, i + 1) or  # 위
+                     dfs(r, c + 1, i + 1) or  # 오른쪽
+                     dfs(r, c - 1, i + 1))    # 왼쪽
+            
+            # 백트래킹: 현재 셀을 방문하지 않은 것으로 표시
+            #현재 경로가 실패했으므로 방문 표시 제거
+            visited.remove((r, c))
+            
+            return result
+        
+        # 보드의 모든 셀에서 시작점으로 시도
+        for r in range(rows):
+            for c in range(cols):
+                if dfs(r, c, 0):
+                    return True
+        
+        return False
+
+        #시간 복잡도 (Time Complexity): O(m * n * 4^L)
+            #m: 보드의 행 수
+            #n: 보드의 열 수
+            #L: 단어의 길이
+            #이유:
+                #각 셀에서 시작할 수 있음: O(m * n)
+                #각 위치에서 4방향으로 탐색 가능: O(4^L)
+                #최악의 경우 모든 경로를 탐색해야 함
+                #따라서 시간 복잡도는 O(m * n * 4^L)
+        #공간 복잡도 (Space Complexity): O(L)
+            #L: 단어의 길이
+            #이유:
+                #재귀 호출 스택의 깊이는 단어의 길이에 비례
+                #visited 집합의 크기도 단어의 길이에 비례
+                #따라서 공간 복잡도는 O(L)