[dolphinflow86] WEEK 08 Solutions

clone-graph/dolphinflow86.py

@@ -0,0 +1,36 @@
+# N is the number of nodes, and E is the number of edges.
+# TC: O(N + E) - visits each node and edge once
+# SC: O(N) - uses a hash map for cloned nodes and the recursion stack
+
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+"""
+
+from typing import Optional
+
+
+class Solution:
+
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if not node:
+            return None
+
+        cloned = {}
+
+        def dfs(curr):
+            if curr in cloned:
+                return cloned[curr]
+
+            copy = Node(curr.val)
+            cloned[curr] = copy
+
+            for neighbor in curr.neighbors:
+                copy.neighbors.append(dfs(neighbor))
+
+            return copy
+
+        return dfs(node)

longest-common-subsequence/dolphinflow86.py

@@ -0,0 +1,17 @@
+# M is the length of text1, and N is the length of text2.
+# TC: O(M * N) - fills a 2D DP table of size (M+1) x (N+1)
+# SC: O(M * N) - uses a 2D array to store intermediate DP values
+class Solution:
+
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        m, n = len(text1), len(text2)
+        dp = [[0] * (n + 1) for _ in range(m + 1)]
+
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                if text1[i - 1] == text2[j - 1]:
+                    dp[i][j] = dp[i - 1][j - 1] + 1
+                else:
+                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
+
+        return dp[m][n]

longest-repeating-character-replacement/dolphinflow86.py

@@ -0,0 +1,22 @@
+# N is the length of string s, and K is the allowed replacements.
+# TC: O(N) - single pass with sliding window
+# SC: O(1) - hash table stores at most 26 uppercase English letters
+class Solution:
+
+    def characterReplacement(self, s: str, k: int) -> int:
+        count = {}
+        max_freq = 0
+        left = 0
+        max_length = 0
+
+        for right in range(len(s)):
+            count[s[right]] = count.get(s[right], 0) + 1
+            max_freq = max(max_freq, count[s[right]])
+
+            while (right - left + 1) - max_freq > k:
+                count[s[left]] -= 1
+                left += 1
+
+            max_length = max(max_length, right - left + 1)
+
+        return max_length

palindromic-substrings/dolphinflow86.py

@@ -0,0 +1,23 @@
+# N is the length of string s.
+# TC: O(N^2) - expands around each center (2N - 1 possible centers)
+# SC: O(1) - uses only constant extra space
+class Solution:
+
+    def expand_around_center(self, s: str, left: int, right: int) -> int:
+        sub_count = 0
+
+        while left >= 0 and right < len(s) and s[left] == s[right]:
+            sub_count += 1
+            left -= 1
+            right += 1
+
+        return sub_count
+
+    def countSubstrings(self, s: str) -> int:
+        count = 0
+
+        for i in range(len(s)):
+            count += self.expand_around_center(s, i, i)
+            count += self.expand_around_center(s, i, i + 1)
+
+        return count

reverse-bits/dolphinflow86.py

@@ -0,0 +1,11 @@
+# 1) Iterate 32 times, getting the last bit of n and putting it to res using bitwise operators.
+# TC: O(1)
+# SC: O(1)
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        res = 0
+        for _ in range(32):
+            bit = n & 1
+            res = (res << 1) | bit
+            n >>= 1
+        return res