Merge pull request #2472 from gcount85/main

Author: jamiebase

coin-change/gcount85.py

@@ -0,0 +1,26 @@
+"""
+# Intuition
+dp[n]은 n원을 만드는데 필요한 최소 동전 개수
+e.g. n = 11일 때, 11원을 만들기 위한 최소 동전 개수는 11에서 coins의 원소를 뺀 dp 값 + 1이다.
+
+# Complexity
+- Time complexity: O(amount * coins.length)인데, coins 배열 길이가 상수라서 무시 => O(amount)
+
+- Space complexity: dp 배열 생성으로 O(amount)
+"""
+
+
+class Solution:
+    def coinChange(self, coins: list[int], amount: int) -> int:
+        coins.sort()
+        INF = float("inf")
+        dp = [INF] * (amount + 1)
+        dp[0] = 0
+        for i in range(amount + 1):
+            if dp[i] == INF:
+                continue
+            for c in coins:
+                if i + c > amount:
+                    break
+                dp[i + c] = min(dp[i + c], dp[i] + 1)
+        return dp[-1] if dp[-1] != INF else -1

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

@@ -0,0 +1,27 @@
+"""
+# Intuition
+이진탐색으로 찾는다.
+
+# Complexity
+- Time complexity: nums의 길이 N일때, O(logN)
+
+- Space complexity: 재귀스택 O(logN)
+"""
+
+
+class Solution:
+    def findMin(self, nums: list[int]) -> int:
+        l, m, r = 0, len(nums) // 2, len(nums) - 1
+
+        def findMinimum(l, m, r):
+            if l == m or r == m:
+                return min(nums[l], nums[r])
+
+            # 오른쪽 구간
+            if nums[m] > nums[r]:
+                return findMinimum(m, (m + r) // 2, r)
+
+            # 왼쪽 구간
+            return findMinimum(l, (l + m) // 2, m)
+
+        return findMinimum(l, m, r)

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

@@ -0,0 +1,18 @@
+"""
+# Intuition
+1) BFS + 큐
+2) DFS + 재귀
+1번으로 풀었다가 2번이 코드가 더 간결해서 바꿨습니다.
+
+# Complexity
+- Time complexity: 모든 노드를 다 봐야 하므로 O(N)
+
+- Space complexity: 재귀 깊이만큼 O(H)
+"""
+
+
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

merge-two-sorted-lists/gcount85.py

@@ -0,0 +1,34 @@
+"""
+# Intuition
+각각의 리스트의 첫 노드를 가리키면서 병합 리스트를 생성한다.
+
+# Complexity
+- Time complexity: list1과 list2의 길이 N, M일때 O(N+M)
+
+- Space complexity: 기존 노드 연결만 바꿈 O(1)
+"""
+
+
+class Solution:
+    def mergeTwoLists(
+        self, list1: Optional[ListNode], list2: Optional[ListNode]
+    ) -> Optional[ListNode]:
+        dummy = ListNode(0)
+        tail = dummy
+
+        while list1 and list2:
+            if list1.val <= list2.val:
+                tail.next = list1
+                list1 = list1.next
+            else:
+                tail.next = list2
+                list2 = list2.next
+            tail = tail.next
+
+        # 남은 쪽 붙이기
+        if list1:
+            tail.next = list1
+        else:
+            tail.next = list2
+
+        return dummy.next

word-search/gcount85.py

@@ -0,0 +1,42 @@
+"""
+# Intuition
+백트래킹으로 풀었습니다.
+
+# Complexity
+- Time complexity: O(M*N*3^L) => M*N 보드 한 칸을 모두 방문하며,
+word 의 길이(L) 횟수 단계 만큼 탐색해야 한다. 매 단계 탐색할 때는 매번 3갈래씩 길을 찾는다.
+
+- Space complexity: 재귀 스택 O(L), visited 크기 O(L)
+"""
+
+
+class Solution:
+    def exist(self, board: list[list[str]], word: str) -> bool:
+        m, n = len(board[0]), len(board)
+        direction = [[0, 1], [0, -1], [1, 0], [-1, 0]]
+
+        def dfs(x, y, cur_step, visited):
+            if cur_step == len(word) - 1:
+                return True
+
+            for dx, dy in direction:
+                nx, ny = x + dx, y + dy
+                if nx < 0 or ny < 0 or nx >= n or ny >= m:
+                    continue
+                if board[nx][ny] != word[cur_step + 1]:
+                    continue
+                if (nx, ny) in visited:
+                    continue
+                visited.add((nx, ny))
+                if dfs(nx, ny, cur_step + 1, visited):
+                    return True
+                visited.discard((nx, ny))
+            return False
+
+        for x, row in enumerate(board):
+            for y, start_word in enumerate(row):
+                if word[0] != start_word:
+                    continue
+                if dfs(x, y, 0, {(x, y)}):
+                    return True
+        return False