feat: add current week problems

Author: kangdaia

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

@@ -0,0 +1,27 @@
+class Solution:
+    def findMin(self, nums: list[int]) -> int:
+        """
+        정렬된 리스트에서 n번 돌아간 상태에서 기존의 첫번째 값 (가장 작은)을 찾는 함수
+
+        방법:
+        Hint2의 Can you think of an algorithm which has O(logN) search complexity?
+        에서 binary search!
+
+        Args:
+            nums (list[int]): n번 돌아간 정수 리스트
+
+        Returns:
+            int: 최초 정렬된 리스트의 첫번째 값
+        """
+        if nums[0] <= nums[-1]:
+            return nums[0]
+        start, end = 0, len(nums) - 1
+        while start < end:
+            if start == end:
+                break
+            mid = start + (end - start) // 2
+            if nums[mid] > nums[end]:
+                start = mid + 1
+            else:
+                end = mid
+        return nums[start]

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

@@ -0,0 +1,26 @@
+# 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 | None) -> int:
+        """주어진 binary tree의 최대 깊이를 찾는 함수
+
+        방법:
+        1. 재귀함수를 생각함. 인자로 현재 head node와 현재의 depth를 받는 재귀함수를 만들어 재귀 반복
+        2. 이 함수 자체가 재귀가 될 수 있다고 판단, 별도의 재귀함수를 삭제함.
+            depth를 넘겨주지 않아도, 앞에 +1을 함으로써 depth가 계산됨.
+
+        Args:
+            root (TreeNode | None): binary tree
+
+        Returns:
+            int: 최대 깊이
+        """
+        if root is None:
+            return 0
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

merge-two-sorted-lists/kangdaia.py

@@ -0,0 +1,37 @@
+# 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 | None, list2: ListNode | None) -> ListNode | None:
+        """두개의 링크드 리스트를 합쳐서 하나의 sorted 링크드 리스트를 만드는 함수
+
+        방법:
+        1. 각각의 리스트 head에서 값을 비교하면서,
+            1번보다 2번의 값이 작으면 1번의 head를 움직이고,
+            반대의 경우 2번의 head를 움직이도록 함.
+            움직이면서 합치는 리스트에 tail.next로 붙여줌
+
+        Args:
+            list1 (ListNode | None): 정렬된 양수 링크드 리스트
+            list2 (ListNode | None): 정렬된 양수 링크드 리스트 2
+
+        Returns:
+            ListNode | None: 하나로 합쳐진 정렬된 링크드 리스트
+        """
+        final = ListNode()
+        tail = final
+        curr1, curr2 = list1, list2
+        while curr1 and curr2:
+            if curr1.val < curr2.val:
+                tail.next = curr1
+                curr1 = curr1.next
+            else:
+                tail.next = curr2
+                curr2 = curr2.next
+            tail = tail.next
+        tail.next = curr1 if curr1 else curr2
+        return final.next

word-search/kangdaia.py

@@ -0,0 +1,39 @@
+class Solution:
+    def exist(self, board: list[list[str]], word: str) -> bool:
+        """m*n 사이즈 보드가 주어졌을 때, word를 만들 수 있는지 true/false로 return 하는 함수
+
+        1. bfs로 queue에 모든 element를 추가하고, 매번 path를 파악해서 word인지 판단하도록 함
+        -> 시간 효율이 안나옴
+        2. dfs 방식 적용. 현재 탐색 중일때, 보드를 #으로 치환해서, 이미 방문한 곳임을 체크
+            - 시작점이 word[0]와 같을 때만 시작
+            - dfs는 전체 path를 기록하지 않고, word가 볼 index를 인자로 받도록 함.
+
+        Args:
+            board (list[list[str]]): 글자를 element로 가진 2d array
+            word (str): 찾아야 할 글자 목록
+
+        Returns:
+            bool: word가 board에 있는지 여부
+        """
+        m, n = len(board[0]), len(board)
+
+        def dfs(row, col, idx):
+            if board[row][col] != word[idx]:
+                return False
+            if idx == len(word) - 1:
+                return True
+            visited = board[row][col]
+            board[row][col] = "#"
+            for r, c in [(row - 1, col), (row + 1, col), (row, col - 1), (row, col + 1)]:
+                if 0 <= r < n and 0 <= c < m:
+                    if dfs(r, c, idx + 1):
+                        board[row][col] = visited
+                        return True
+            board[row][col] = visited
+            return False
+
+        for ir in range(n):
+            for ic in range(m):
+                if board[ir][ic] == word[0] and dfs(ir, ic, 0):
+                    return True
+        return False