From 775b2d0483519fa7628da5c1e3a0f739012cb8c9 Mon Sep 17 00:00:00 2001 From: hu6r1s Date: Mon, 22 Sep 2025 12:50:52 +0900 Subject: [PATCH 1/5] feat: Solve invert-binary-tree problem --- invert-binary-tree/hu6r1s.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 invert-binary-tree/hu6r1s.py diff --git a/invert-binary-tree/hu6r1s.py b/invert-binary-tree/hu6r1s.py new file mode 100644 index 000000000..a898e0350 --- /dev/null +++ b/invert-binary-tree/hu6r1s.py @@ -0,0 +1,14 @@ +# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]: + if not root: + return + root.left, root.right = root.right, root.left + self.invertTree(root.left) + self.invertTree(root.right) + return root From 56f7219ed4c5bc6c401111e6b16c4e7d87df9b16 Mon Sep 17 00:00:00 2001 From: hu6r1s Date: Mon, 22 Sep 2025 13:02:51 +0900 Subject: [PATCH 2/5] feat: Solve search-in-rotated-sorted-array problem --- search-in-rotated-sorted-array/hu6r1s.py | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 search-in-rotated-sorted-array/hu6r1s.py diff --git a/search-in-rotated-sorted-array/hu6r1s.py b/search-in-rotated-sorted-array/hu6r1s.py new file mode 100644 index 000000000..0dee99283 --- /dev/null +++ b/search-in-rotated-sorted-array/hu6r1s.py @@ -0,0 +1,3 @@ +class Solution: + def search(self, nums: List[int], target: int) -> int: + return nums.index(target) if target in nums else -1 From c9cdbfd788abbdb97fcac8f7457d5a58215ec78e Mon Sep 17 00:00:00 2001 From: hu6r1s Date: Tue, 23 Sep 2025 11:18:51 +0900 Subject: [PATCH 3/5] feat: Solve course-schedule problem --- course-schedule/hu6r1s.py | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 course-schedule/hu6r1s.py diff --git a/course-schedule/hu6r1s.py b/course-schedule/hu6r1s.py new file mode 100644 index 000000000..840b59727 --- /dev/null +++ b/course-schedule/hu6r1s.py @@ -0,0 +1,37 @@ +from collections import defaultdict + +class Solution: + # def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool: + # for pre_x, pre_y in prerequisites: + # if [pre_y, pre_x] in prerequisites: + # return False + # return True + + + def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool: + d = defaultdict(list) + + for x, y in prerequisites: + d[x].append(y) + + visited = set() + finished = set() + + def dfs(course): + if course in visited: + return False + if course in finished: + return True + + visited.add(course) + for v in d[course]: + if not dfs(v): + return False + visited.remove(course) + finished.add(course) + return True + + for course in list(d): + if not dfs(course): + return False + return True From 9492b15a99a298e6f48762e6f72b3d08b76b94c8 Mon Sep 17 00:00:00 2001 From: hu6r1s Date: Tue, 23 Sep 2025 11:32:59 +0900 Subject: [PATCH 4/5] feat: Solve jump-game problem --- jump-game/hu6r1s.py | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 jump-game/hu6r1s.py diff --git a/jump-game/hu6r1s.py b/jump-game/hu6r1s.py new file mode 100644 index 000000000..d1be532b2 --- /dev/null +++ b/jump-game/hu6r1s.py @@ -0,0 +1,29 @@ +class Solution: + # def canJump(self, nums: List[int]) -> bool: + # if len(nums) == 1: + # return True + + # idx = 0 + # while idx < len(nums): + # if idx == len(nums) - 1: + # return True + # if nums[idx] == 0: + # return False + + # idx += nums[idx] + # return False + + + def canJump(self, nums: List[int]) -> bool: + maxReach = 0 + for i, num in enumerate(nums): + if i > maxReach: + return False + maxReach = max(maxReach, i + num) + return True +""" +while idx < len(nums) +if nums[idx] == 0 +break +idx += nums[idx] +""" From e56c6624fe02d793c4de9c196e3a0962b2d3ab64 Mon Sep 17 00:00:00 2001 From: hu6r1s Date: Sat, 27 Sep 2025 13:45:26 +0900 Subject: [PATCH 5/5] feat: Solve merge-k-sorted-lists problem --- merge-k-sorted-lists/hu6r1s.py | 69 ++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 merge-k-sorted-lists/hu6r1s.py diff --git a/merge-k-sorted-lists/hu6r1s.py b/merge-k-sorted-lists/hu6r1s.py new file mode 100644 index 000000000..a3102c027 --- /dev/null +++ b/merge-k-sorted-lists/hu6r1s.py @@ -0,0 +1,69 @@ +# Definition for singly-linked list. +# class ListNode: +# def __init__(self, val=0, next=None): +# self.val = val +# self.next = next +import heapq +class Solution: + """ + 브루트포스 + """ + # def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]: + # dummy = curr = ListNode() + # while any(lists): + # val, idx = min((li.val, idx) for idx, li in enumerate(lists) if li) + # curr.next = ListNode(val) + # curr = curr.next + # lists[idx] = lists[idx].next + # return dummy.next + + """ + 최소힙 활용 + """ + # def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]: + # heap = [(li.val, idx) for idx, li in enumerate(lists) if li] + # heapq.heapify(heap) + + # dummy = curr = ListNode() + # while heap: + # val, idx = heapq.heappop(heap) + # curr.next = ListNode(val) + # curr = curr.next + + # lists[idx] = lists[idx].next + # if lists[idx]: + # heapq.heappush(heap, (lists[idx].val, idx)) + # return dummy.next + + """ + 분할정복과 재귀 활용 + """ + def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]: + def mergeTwoLists(li1, li2): + dummy = node = ListNode(-1) + while li1 and li2: + if li1.val < li2.val: + node.next = li1 + li1 = li1.next + else: + node.next = li2 + li2 = li2.next + node = node.next + node.next = li1 if li1 else li2 + return dummy.next + + if len(lists) == 0: + return None + + def dfs(low, high): + if low == high: + return lists[low] + if low + 1 == high: + return mergeTwoLists(lists[low], lists[high]) + + mid = (low + high) // 2 + li1 = dfs(low, mid) + li2 = dfs(mid + 1, high) + return mergeTwoLists(li1, li2) + + return dfs(0, len(lists) - 1)