[yuseok89] WEEK 15 Solutions

construct-binary-tree-from-preorder-and-inorder-traversal/yuseok89.py

@@ -0,0 +1,33 @@
+# TC: O(N)
+# SC: O(N)
+# 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 buildTree(self, preorder: list[int], inorder: list[int]) -> TreeNode | None:
+
+        inorder_map = {val: idx for idx, val in enumerate(inorder)}
+        preorder_idx = 0
+
+        def build(left: int, right: int) -> TreeNode | None:
+            nonlocal preorder_idx
+
+            if left > right:
+                return None
+
+            root_val = preorder[preorder_idx]
+            root = TreeNode(root_val)
+            preorder_idx += 1
+
+            mid = inorder_map[root_val]
+
+            root.left = build(left, mid - 1)
+            root.right = build(mid + 1, right)
+
+            return root
+
+        return build(0, len(inorder) - 1)
+

longest-palindromic-substring/yuseok89.py

@@ -0,0 +1,29 @@
+# TC: O(N^2)
+# SC: O(1)
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+
+        n = len(s)
+        max_len, left = 1, 0
+
+        for mid in range(n):
+            l, r = mid, mid
+
+            while l >= 0 and r < n and s[l] == s[r]:
+                l -= 1
+                r += 1
+
+            if max_len < r - l - 1:
+                max_len, left = r - l - 1, l + 1
+
+            l, r = mid, mid + 1
+
+            while l >= 0 and r < n and s[l] == s[r]:
+                l -= 1
+                r += 1
+
+            if max_len < r - l - 1:
+                max_len, left = r - l - 1, l + 1
+
+        return s[left:left + max_len]
+

rotate-image/yuseok89.py

@@ -0,0 +1,25 @@
+# TC: O(N^2)
+# SC: O(1)
+class Solution:
+    def rotate(self, matrix: list[list[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+
+        n = len(matrix)
+
+        for k in range(0, n // 2):
+
+            y11, x11 = k, k
+            y12, x12 = k, n - 1 - k
+            y21, x21 = n - 1 - k, k
+            y22, x22 = n - 1 - k, n - 1 - k
+
+            for _ in range(0, n - 1 - k * 2):
+                matrix[y11][x11], matrix[y21][x21], matrix[y22][x22], matrix[y12][x12] = matrix[y21][x21], matrix[y22][x22], matrix[y12][x12], matrix[y11][x11]
+
+                x11 += 1
+                y12 += 1
+                x22 -= 1
+                y21 -= 1
+

subtree-of-another-tree/yuseok89.py

@@ -0,0 +1,42 @@
+# TC: O(N)
+# SC: O(N)
+class Solution:
+    def isSubtree(self, root: TreeNode | None, subRoot: TreeNode | None) -> bool:
+
+        def isSameTree(p, q):
+            if not p and not q:
+                return True
+            if not p or not q or p.val != q.val:
+                return False
+
+            return isSameTree(p.left, q.left) and isSameTree(p.right, q.right)
+
+        def get_size(node):
+            if not node:
+                return 0
+            return 1 + get_size(node.left) + get_size(node.right)
+
+        target_size = get_size(subRoot)
+        is_match = False
+
+        def check_tree(node):
+            nonlocal is_match
+
+            if not node or is_match:
+                return 0
+
+            left_size = check_tree(node.left)
+            right_size = check_tree(node.right)
+
+            current_size = 1 + left_size + right_size
+
+            if current_size == target_size:
+                if isSameTree(node, subRoot):
+                    is_match = True
+
+            return current_size
+
+        check_tree(root)
+
+        return is_match
+