[liza0525] WEEK 15 Solutions

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

@@ -0,0 +1,29 @@
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
+        inorder_idx_map = {
+            val: idx
+            for idx, val in enumerate(inorder)
+        }
+
+        def dfs(pre_start, pre_end, in_start, in_end):
+            if pre_start > pre_end or in_start > in_end:
+                return None
+
+            node = TreeNode()
+            node.val = preorder[pre_start]
+
+            in_idx = inorder_idx_map[node.val]
+            left_size = in_idx - in_start
+
+            node.left = dfs(
+                pre_start + 1, pre_start + left_size,
+                in_start, in_idx - 1,
+            )
+            node.right = dfs(
+                pre_start + left_size + 1, pre_end,
+                in_idx + 1, in_end,
+            )
+
+            return node
+
+        return dfs(0, len(preorder) - 1, 0, len(inorder) - 1)

house-robber-ii/liza0525.py

@@ -0,0 +1,23 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return nums[0]
+
+        dp1 = [0 for _ in range(len(nums))]
+        dp2 = [0 for _ in range(len(nums))]
+
+        for i in range(len(nums)):
+            if i == 0 or i == 1:
+                dp1[i] = nums[i]
+            else:
+                dp1[i] = nums[i] + max(dp1[:i - 1])
+
+        nums = nums[1:] + [nums[0]]
+
+        for i in range(len(nums)):
+            if i == 0 or i == 1:
+                dp2[i] = nums[i]
+            else:
+                dp2[i] = nums[i] + max(dp2[:i - 1])
+
+        return max(dp1[:-1] + dp2[:-1])

longest-palindromic-substring/liza0525.py

@@ -0,0 +1,31 @@
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        res = ""
+        len_res = 0
+        len_s = len(s)
+
+        for i in range(len_s):
+            left, right = i, i
+            while 0 <= left and right < len_s:
+                if s[left] == s[right]:
+                    if right - left + 1 > len_res:
+                        res = s[left:right + 1]
+                        len_res = right - left + 1
+                    left -= 1
+                    right += 1
+                else:
+                    break
+
+        for i in range(len_s - 1):
+            left, right = i, i + 1
+            while 0 <= left and right < len_s:
+                if s[left] == s[right]:
+                    if right - left + 1 > len_res:
+                        res = s[left:right + 1]
+                        len_res = right - left + 1
+                    left -= 1
+                    right += 1
+                else:
+                    break
+
+        return res

rotate-image/liza0525.py

@@ -0,0 +1,21 @@
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        len_matrix = len(matrix)
+
+
+        for i in range(len_matrix // 2):
+            for j in range(i, len_matrix - i - 1):
+                (
+                    matrix[i][j],
+                    matrix[j][len_matrix - i - 1],
+                    matrix[len_matrix - i - 1][len_matrix - j - 1],
+                    matrix[len_matrix - j - 1][i],
+                ) = (
+                    matrix[len_matrix - j - 1][i],
+                    matrix[i][j],
+                    matrix[j][len_matrix - i - 1],
+                    matrix[len_matrix - i - 1][len_matrix - j - 1],
+                )

subtree-of-another-tree/liza0525.py

@@ -0,0 +1,32 @@
+# 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 isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
+        def check_same(node, subnode):
+            if not node and not subnode:
+                return True
+            elif node and subnode:
+
+                if node.val != subnode.val:
+                    return False
+
+                return (
+                    check_same(node.left, subnode.left)
+                    and check_same(node.right, subnode.right)
+                )
+            return False
+
+        def dfs(node):
+            if not node:
+                return False
+
+            if node.val == subRoot.val and check_same(node, subRoot):
+                return True
+
+            return dfs(node.left) or dfs(node.right)
+
+        return dfs(root)