[SunaDu] Week 9

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

     return nums[left] 
 # 153. Find Minimum in Rotated Sorted Array 
 > **why binary search works in a "rotated" sorted array?**   
 > rotated sorted array consists of **two sorted subarrays**, and the minimum value is the second sorted subarray's first element.   
 > so 👉 find the point that second sorted subarray starts.    
 > 
 > - if nums[mid] > nums[right]? => the pivot point is in the right half.   
 > - if nums[mid] <= nums[right]? => the pivot point is in the left half.   
 > - loop until left and right are the same. 
 def findMinBS(self, nums: List[int]) -> int: 
     left = 0 
     right = len(nums) - 1 
     while left < right: 
         mid = (left + right) // 2 
         if nums[mid] > nums[right]: 
             left = mid + 1 
         else: 
             right = mid 
     return nums[left] 
@@ -0,0 +1,15 @@
+'''
+# 153. Find Minimum in Rotated Sorted Array
+
+## Time Complexity: O(n)
+- min() iterates through all elements to find the smallest one.
+
+## Space Complexity: O(1)
+- no extra space is used.
+'''
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return nums[0]
+
+        return min(nums)

linked-list-cycle/dusunax.py

@@ -0,0 +1,33 @@
+'''
+# 141. Linked List Cycle
+
+use two pointers, Floyd's Tortoise and Hare algorithm
+
+> Tortoise and Hare algorithm  
+>- slow pointer moves one step at a time
+>- fast pointer moves two steps at a time
+>- if there is a cycle, slow and fast will meet at some point
+>- if there is no cycle, fast will reach the end of the list
+
+## Time Complexity: O(n)
+In the worst case, we need to traverse the entire list to determine if there is a cycle.
+
+## Space Complexity: O(1)
+no extra space is used, only the two pointers.
+'''
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        if not head or not head.next:
+            return False
+
+        slow = head
+        fast = head
+
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+
+            if slow == fast:
+                return True
+
+        return False

pacific-atlantic-water-flow/dusunax.py

@@ -0,0 +1,42 @@
+'''
+# 417. Pacific Atlantic Water Flow
+
+## Time Complexity: O(n * m)
+- dfs is called for each cell in the grid, and each cell is visited once.
+
+## Space Complexity: O(n * m)
+- pacific and atlantic sets store the cells that can flow to the pacific and atlantic oceans respectively.
+'''
+class Solution:
+    def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]:
+        if len(heights) == 1 and len(heights[0]) == 1:
+            return [[0, 0]]
+
+        max_row, max_col = len(heights), len(heights[0])
+        pacific, atlantic = set(), set()
+        directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+
+        def dfs(r, c, visited, prev_height):
+            out_of_bound = r < 0 or c < 0 or r >= max_row or c >= max_col
+            if out_of_bound:
+                return
+
+            current = heights[r][c]
+            is_visited = (r, c) in visited
+            is_uphill = current < prev_height
+            if is_visited or is_uphill:
+                return
+
+            visited.add((r, c))
+
+            for dr, dc in directions:
+                dfs(r + dr, c + dc, visited, current)
+
+        for r in range(max_row):
+            dfs(r, 0, pacific, heights[r][0]) # left
+            dfs(r, max_col - 1, atlantic, heights[r][max_col - 1]) # right
+        for c in range(max_col):
+            dfs(0, c, pacific, heights[0][c]) # top
+            dfs(max_row - 1, c, atlantic, heights[max_row - 1][c]) # bottom
+
+        return list(pacific & atlantic)