Merge pull request DaleStudy#2338 from doh6077/main

TonyKim9401 · web-flow · commit 27da15ec5d0b · 2026-02-20T14:51:36.000-05:00
[doh6077] WEEK 15 solutions
diff --git a/binary-tree-level-order-traversal/doh6077.py b/binary-tree-level-order-traversal/doh6077.py
@@ -0,0 +1,30 @@
+from collections import deque
+# 102. Binary Tree Level Order Traversal
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        # 1. Edge Case: Empty Tree
+        if not root:
+            return [] 
+        
+        result = [] 
+        queue = deque([root])
+        
+        while queue:
+            # 2. Capture the number of nodes at the current level
+            level_size = len(queue)
+            current_level_nodes = []
+            
+            for _ in range(level_size):
+                current_node = queue.popleft()
+                current_level_nodes.append(current_node.val)
+                
+                # 3. Add children to the queue for the NEXT level
+                if current_node.left:
+                    queue.append(current_node.left)
+                if current_node.right: 
+                    queue.append(current_node.right)
+            
+            # Add the finished level to our result
+            result.append(current_level_nodes)
+            
+        return result
diff --git a/house-robber/doh6077.py b/house-robber/doh6077.py
@@ -0,0 +1,28 @@
+# Week1 
+# 198. House Robber
+# Tabulation 
+# Dynamic Programming 
+
+
+# two options: either rober or not 
+
+class Solution:
+    def rob(self, nums: List[int]) -> int:        
+        # Top Down DP
+
+        n = len(nums)
+
+        if n == 1:
+            return nums[0]
+        if n == 2:
+            return max(nums[0], nums[1])
+        memo = {0: nums[0], 1: max(nums[0], nums[1])}
+        def helper(i):
+
+            if i in memo:
+                return memo[i]
+            else:
+                memo[i]= max(nums[i] + helper(i-2), helper(i-1))
+                return memo[i]
+        
+        return helper(n-1)
diff --git a/kth-smallest-element-in-a-bst/doh6077.py b/kth-smallest-element-in-a-bst/doh6077.py
@@ -0,0 +1,23 @@
+# 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:
+    # Time Complexity O(N)
+    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
+        ans = []
+        final = 0 
+        def dfs(node):
+            nonlocal final
+            if not node:
+                return 
+            dfs(node.left)
+            ans.append(node.val)
+            if len(ans) == k:
+                final = node.val
+            if len(ans) < k:
+                dfs(node.right)
+        dfs(root)
+        return final
diff --git a/longest-palindromic-substring/doh6077.py b/longest-palindromic-substring/doh6077.py
@@ -0,0 +1,30 @@
+# 5. Longest Palindromic Substring
+# https://leetcode.com/problems/longest-palindromic-substring/
+
+
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        #Expand Around Center
+        res = ""
+        resLen = 0 
+
+        for i in range(len(s)):
+            # odd length 
+            l, r = i, i
+            while l >= 0 and r < len(s) and s[l] == s[r]:
+                if (r - l + 1) > resLen:
+                    res = s[l:r+1]
+                    resLen = r - l + 1
+                l -= 1
+                r += 1
+            
+            # even length 
+            l, r = i, i + 1
+            while l >= 0 and r < len(s) and s[l] == s[r]:
+                if (r - l + 1) > resLen:
+                    res = s[l:r+1]
+                    resLen = r - l + 1
+                l -= 1
+                r += 1
+                
+        return res
diff --git a/rotate-image/doh6077.py b/rotate-image/doh6077.py
@@ -0,0 +1,29 @@
+# https://leetcode.com/problems/rotate-image/
+# 48. Rotate Image
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        # First Try - Thought process:
+        # group values by column index (j) to rebuild rows
+        # Brute force: create an extra 2D matrix and then copy it back into matrix
+        # Needs optimization: this approach uses extra space
+        matrix_result = [[] for _ in range(len(matrix))]
+        for i in reversed(matrix):
+            for j, value in enumerate(i):
+                matrix_result[j].append(value)
+        for r in range(len(matrix)):
+            matrix[r] = matrix_result[r]
+        
+        # Youtube Solution - Transpose Operation + hr 
+        # Swap i, js
+        n = len(matrix)
+        for i in range(n):
+            for j in range(i + 1, n):
+                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
+
+        # Reflection
+        for i in range(n):
+            for j in range(n // 2):
+                matrix[i][j], matrix[i][n - j - 1] = matrix[i][n - j - 1], matrix[i][j]
diff --git a/subtree-of-another-tree/doh6077.py b/subtree-of-another-tree/doh6077.py
@@ -0,0 +1,43 @@
+from collections import deque
+from typing import Optional
+
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+# 572. Subtree of Another Tree
+# https://leetcode.com/problems/subtree-of-another-tree/description/
+class Solution:
+    def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
+        # Use BFS => Queue 
+        # Edge cases
+        if subRoot is None:
+            return True
+        if root is None:
+            return False
+
+        def helper(node: Optional[TreeNode], subNode: Optional[TreeNode]) -> bool:
+            if node is None and subNode is None:
+                return True
+            if node is None or subNode is None:
+                return False
+            if node.val != subNode.val:
+                return False
+            return helper(node.left, subNode.left) and helper(node.right, subNode.right)
+
+        q = deque([root])
+
+        while q:
+            curr = q.popleft()
+
+            # Only attempt full compare when root values match
+            if curr.val == subRoot.val and helper(curr, subRoot):
+                return True
+
+            if curr.left:
+                q.append(curr.left)
+            if curr.right:
+                q.append(curr.right)
+
+        return False
