[daiyongg-kim] WEEK 07 solutions

longest-substring-without-repeating-characters/daiyongg-kim.py

@@ -0,0 +1,16 @@
+class Solution:
+    # TC O(n^2)
+    # SC O(1)
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        max_size = 0
+        n = len(s)
+        for left in range(n):
+            saw = set()
+            for right in range(left, n):
+                if s[right] in saw:
+                    break
+                else:
+                    saw.add(s[right])
+                    max_size = max(max_size, right - left + 1)
+
+        return max_size

number-of-islands/daiyongg-kim.py

@@ -0,0 +1,24 @@
+if not grid:
+            return 0
+
+        m, n = len(grid), len(grid[0])
+
+        island_count = 0
+
+        def dfs(i, j):
+            if i < 0 or i >= m or j < 0 or j >= n or grid[i][j] != "1":
+                return
+            grid[i][j] = "#"
+
+            dfs(i - 1, j)
+            dfs(i + 1, j)
+            dfs(i, j - 1)
+            dfs(i, j + 1)
+
+        for i in range(m):
+            for j in range(n):
+                if grid[i][j] == "1":
+                    dfs(i, j)
+                    island_count += 1
+
+        return island_count

reverse-linked-list/daiyongg-kim.py

@@ -0,0 +1,20 @@
+# 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]:
+        curr = head
+        prev = None
+
+        # Time Complexity : O(n)
+        # Space Complexity : O(1)
+        while curr:
+            temp = curr.next
+            curr.next = prev
+            prev = curr
+            curr = temp
+
+        return prev

set-matrix-zeroes/daiyongg-kim.py

@@ -0,0 +1,33 @@
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        # Time Complexity(n^2)
+        # Space Complexity O(1)
+        row = len(matrix)
+        col = len(matrix[0])
+        row_zero = False
+
+        for r in range(row):
+            for c in range(col):
+                if matrix[r][c] == 0:
+                    matrix[0][c] = 0
+
+                    if r > 0:
+                        matrix[r][0] = 0
+                    else:
+                        row_zero = True
+
+        for r in range(1, row):
+            for c in range(1, col):
+                if matrix[0][c] == 0 or matrix[r][0] == 0:
+                    matrix[r][c] = 0
+
+        if matrix[0][0] == 0:
+            for r in range(row):
+                matrix[r][0] = 0
+
+        if row_zero:
+            for c in range(col):
+                matrix[0][c] = 0

unique-paths/daiyongg-kim.py

@@ -0,0 +1,12 @@
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        # $Paths(r, c) = Paths(r-1, c) + Paths(r, c-1)$
+
+        dp = [ [1] * n for _ in range(m) ]
+
+        # DP Approach
+        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[-1][-1]