[kangdaia] WEEK 07 Solutions

number-of-islands/kangdaia.py

@@ -0,0 +1,40 @@
+class Solution:
+    def numIslands(self, grid: list[list[str]]) -> int:
+        """1이 땅이고, 0이 바다로 표현한 2D리스트에서 연결되지 않은 땅 (섬)의 갯수를 구하는 함수
+
+        방법:
+        1. deque를 사용해 BFS로 풀이
+            - 1이 땅인 경우, 섬 갯수 +1, 그리고 해당 땅과 연결된 땅을 모두 0으로 바꿔주며 탐색
+        2. deque 대신 stack을 사용해 DFS로 풀이
+        시간 복잡도: O(m*n) - 모든 땅을 탐색하는 경우
+        공간 복잡도: O(m*n) - 최악의 경우 모든 땅이 연결되어 있는 경우
+
+        Args:
+            grid (list[list[str]]): 1과 0으로 구성된 2d array 지도
+
+        Returns:
+            int: 총 땅 갯수
+        """
+
+        if not grid or not grid[0]:
+            return 0
+
+        m, n = len(grid), len(grid[0])
+        directions = ((1, 0), (-1, 0), (0, 1), (0, -1))
+        islands = 0
+
+        for x in range(m):
+            for y in range(n):
+                if grid[x][y] != "1":
+                    continue
+                islands += 1
+                stack = [(x, y)]
+                grid[x][y] = "0"
+                while stack:
+                    i_x, i_y = stack.pop()
+                    for dx, dy in directions:
+                        nx, ny = i_x + dx, i_y + dy
+                        if 0 <= nx < m and 0 <= ny < n and grid[nx][ny] == "1":
+                            grid[nx][ny] = "0"
+                            stack.append((nx, ny))
+        return islands

reverse-linked-list/kangdaia.py

@@ -0,0 +1,27 @@
+from typing import Optional
+
+
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+class Solution:
+    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        """링크드 리스트를 뒤집어서 역순의 링크드 리스트를 만드는 함수
+
+        Args:
+            head (Optional[ListNode]): 주어진 링크드 리스트
+
+        Returns:
+            Optional[ListNode]: 뒤집어진 링크드 리스트
+        """
+        if head is None or head.next is None:
+            return head
+        curr = head.next
+        new_head = self.reverseList(head.next)
+        curr.next = head
+        head.next = None
+        return new_head

set-matrix-zeroes/kangdaia.py

@@ -0,0 +1,25 @@
+class Solution:
+    def setZeroes(self, matrix: list[list[int]]) -> None:
+        """
+        Hint 가이드에 따라 풀이
+
+        Do not return anything, modify matrix in-place instead.
+        """
+        m, n = len(matrix), len(matrix[0])
+        first_row = any(matrix[0][j] == 0 for j in range(n))
+        first_col = any(matrix[i][0] == 0 for i in range(m))
+        for i in range(1, m):
+            for j in range(1, n):
+                if matrix[i][j] == 0:
+                    matrix[i][0] = 0
+                    matrix[0][j] = 0
+        for i in range(1, m):
+            for j in range(1, n):
+                if matrix[i][0] == 0 or matrix[0][j] == 0:
+                    matrix[i][j] = 0
+        if first_col:
+            for i in range(m):
+                matrix[i][0] = 0
+        if first_row:
+            for j in range(n):
+                matrix[0][j] = 0

unique-paths/kangdaia.py

@@ -0,0 +1,27 @@
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        """격자에서 (0, 0) 위치에서 시작해 (m-1, n-1) 위치에 도달하는 경로의 수를 구하는 함수
+
+        방법:
+        1. 최적의 경로 -> DP 문제!
+            - 각 위치에서는 오른쪽과 아래로만 가지 못함
+            - 따라서, dp[i][j] = dp[i - 1][j] + dp[i][j - 1]로 표현 가능
+        시간 복잡도: O(m*n) - 모든 위치에 대해 계산하는 경우
+        공간 복잡도: O(m*n) - dp 테이블을 저장하는 경우
+
+        Args:
+            m (int): 격자의 행 갯수
+            n (int): 격자의 열 갯수
+
+        Returns:
+            int: (m-1, n-1) 위치에 도달하는 경로의 수
+        """
+        dp = [[0] * n for _ in range(m)]
+        for i in range(m):
+            dp[i][0] = 1
+        for j in range(n):
+            dp[0][j] = 1
+        for i in range(1, m):
+            for j in range(1, n):
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        return dp[m - 1][n - 1]