[Leo] 3rd Week solutions

Author: leokim0922

climbing-stairs/Leo.py

@@ -0,0 +1,12 @@
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        fast, slow = 1, 1
+
+        for i in range(n - 1):
+            tmp = fast
+            fast = fast + slow
+            slow = tmp
+
+        return fast
+
+        ## TC: O(n), SC(1)

maximum-depth-of-binary-tree/Leo.py

@@ -0,0 +1,14 @@
+# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+
+        return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
+
+        ## TC: O(n), SC: O(n) or O(logn) if it is balanced

meeting-rooms/Leo.py

@@ -0,0 +1,11 @@
+class Solution:
+    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
+        intervals.sort() ## nlogn
+
+        for i in range(len(intervals) - 1):
+            if intervals[i][1] > intervals[i+1][0]:
+                return False
+
+        return True
+
+        ## TC: n(nlogn), SC: O(1)

same-tree/Leo.py

@@ -0,0 +1,14 @@
+# 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 isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
+        if p and q:
+            return p.val == q.val and self.isSameTree(p.right, q.right) and self.isSameTree(p.left, q.left)
+        else:
+            return p == q
+
+        ## TC: O(n), SC: O(n) or O(logn) if it is balanced

subtree-of-another-tree/Leo.py

@@ -0,0 +1,29 @@
+# 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 dfs(root, subroot):
+            if not root and not subroot:
+                return True
+            if not root or not subroot:
+                return False
+            if root.val != subroot.val:
+                return False
+
+            return dfs(root.left, subroot.left) and dfs(root.right, subroot.right)
+
+        def solve(root, subroot):
+            if not root:
+                return False
+            if dfs(root, subroot):
+                return True
+            return solve(root.left, subroot) or solve(root.right, subroot)
+
+        return solve(root, subRoot)
+
+        ## TC: O(mn), where m and n denote len(subroot) and len(root)
+        ## SC: O(m+n)