[Chaedie] Week 11

binary-tree-maximum-path-sum/Chaedie.py

@@ -0,0 +1,39 @@
+# 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
+
+"""
+Solution: DFS
+    1) dfs 로 left, right 각각의 max 값을 구한다.
+    2) maxSum 을 업데이트하고, 
+    3) return value 로는 leftMax 또는 rightMax 와의 합만 리턴한다. 
+    (left, right 를 둘 다 포함하는 경우와 둘 중 하나만 선택하는 경우를 나눔)
+
+Time: O(n)
+Space: O(n)
+
+"""
+
+
+class Solution:
+    def maxPathSum(self, root: Optional[TreeNode]) -> int:
+        maxSum = root.val
+
+        def dfs(root):
+            nonlocal maxSum
+            if not root:
+                return 0
+
+            leftMax = dfs(root.left)
+            rightMax = dfs(root.right)
+            leftMax = max(leftMax, 0)
+            rightMax = max(rightMax, 0)
+
+            maxSum = max(maxSum, root.val + leftMax + rightMax)
+            return root.val + max(leftMax, rightMax)
+
+        dfs(root)
+        return maxSum

graph-valid-tree/Chaedie.py

@@ -0,0 +1,39 @@
+"""
+Conditions of Valid Tree
+1) no Loop
+2) all nodes has to be connected
+
+Time: O(node + edge)
+Space: O(node + edge)
+"""
+
+
+class Solution:
+    def validTree(self, n: int, edges: List[List[int]]) -> bool:
+        if not n:
+            return True
+        if len(edges) != n - 1:
+            return False
+
+        # Make Graph
+        graph = {i: [] for i in range(n)}
+        for n1, n2 in edges:
+            graph[n1].append(n2)
+            graph[n2].append(n1)
+
+        # loop check
+        visit = set()
+
+        def dfs(i, prev):
+            if i in visit:
+                return False
+
+            visit.add(i)
+            for j in graph[i]:
+                if j == prev:
+                    continue
+                if not dfs(j, i):
+                    return False
+            return True
+
+        return dfs(0, None) and n == len(visit)

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

@@ -0,0 +1,23 @@
+"""
+Solution: BFS 
+Time: O(n)
+Space: O(n)
+"""
+
+
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+
+        q = deque([root])
+        maxLevel = 0
+        while q:
+            maxLevel += 1
+            for i in range(len(q)):
+                node = q.popleft()
+                if node.left:
+                    q.append(node.left)
+                if node.right:
+                    q.append(node.right)
+        return maxLevel

merge-intervals/Chaedie.py

@@ -0,0 +1,19 @@
+"""
+Time: O(n log(n))
+Space: O(n)
+"""
+
+
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        intervals.sort(key=lambda x: x[0])
+        result = [intervals[0]]
+
+        for start, end in intervals[1:]:
+            prev = result[-1]
+
+            if prev[0] <= start <= prev[1]:
+                result[-1][1] = max(prev[1], end)
+            else:
+                result.append([start, end])
+        return result

reorder-list/Chaedie.py

@@ -0,0 +1,42 @@
+"""
+가장 뒤부터 돌아오는 방법을 찾아야한다.
+1) 재귀 스택 방식
+2) 새로운 리스트를 만드는 방법
+3) two pointer 로 반 잘라서 reverse 한 뒤 merge
+"""
+
+"""
+Solution: 3) Two pointer 
+Time: O(n)
+Space: O(1)
+"""
+
+
+class Solution:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+
+        # 절반 자르기
+        slow, fast = head, head.next
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+
+        # Reverse
+        second = slow.next
+        slow.next = None
+        prev = None
+        while second:
+            tmp = second.next
+            second.next = prev
+            prev = second
+            second = tmp
+
+        # Merge
+        first = head
+        second = prev
+        while second:
+            tmp1, tmp2 = first.next, second.next
+            first.next = second
+            second.next = tmp1
+            first = tmp1
+            second = tmp2