Merge pull request #2286 from doh6077/main

[doh6077] WEEK 11 solutions

Author: TonyKim9401

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

@@ -0,0 +1,48 @@
+# 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
+from collections import deque
+class Solution:
+    def maxPathSum(self, root: Optional[TreeNode]) -> int:
+
+        # # Initially thought I need to use BFS ( misunderstood the question)
+        # if not root:
+        #     return 
+        # queue = deque([root])
+        # result = []
+        # val = 0
+        # max_sum = float('-inf') 
+        # while queue:
+        #     currentNode = queue.popleft()
+        #     result.append(currentNode.val)
+        #     val += currentNode.val
+
+        #     if currentNode.left:
+        #         queue.append(currentNode.left)
+        #         val += currentNode.left.val
+        #     if currentNode.right:
+        #         queue.append(currentNode.right)
+        #         val += currentNode.right.val
+        #     max_sum = max(val, max_sum)
+        #     val = 0
+        # return max_sum
+        res = [root.val]
+
+        def dfs(root):
+            if not root:
+                return 0 
+            leftMax = dfs(root.left)
+            rightMax = dfs(root.right)
+            # 자식 값이 음수일경우 0으로 처리 
+            leftMax = max(leftMax, 0)
+            rightMax = max(rightMax, 0)
+            # "지금까지 발견한 경로 중 최고의 합"을 res[0]에 저장
+            # Job 1: 나를 꺾임점(Anchor)으로 하는 '아치형' 경로 계산
+            res[0] = max(res[0], root.val + leftMax + rightMax)
+            # Job 2: 부모에게 올릴 '직선' 경로 리턴
+            return root.val + max(leftMax, rightMax)
+        dfs(root)
+        return res[0]

graph-valid-tree/doh6077.py

@@ -0,0 +1,28 @@
+class Solution:
+    def validTree(self, n: int, edges: List[List[int]]) -> bool:
+        # Valid Tree
+        # 1. no loop
+        # 2. no disconnected node 
+        # Use DFS and Hashset to track visited nodes 
+        if not n:
+            return True
+        
+        adj = {i:[] for i in range(n)}
+        for n1, n2 in edges:
+            adj[n1].append(n2)
+            adj[n2].append(n1)
+        visit = set()
+        def dfs(i, prev):
+            # Base case
+            if i in visit:
+                return False
+            visit.add(i)
+            # check neighbor nodes 
+            for j in adj[i]:
+                if j == prev:
+                    continue
+                if not dfs(j,i):
+                    return False
+            return True
+
+        return dfs(0, -1) and n == len(visit)

merge-intervals/doh6077.py

@@ -0,0 +1,40 @@
+# 56. Merge Intervals
+
+# First Try: 
+# Time Complexity:O(N)
+# Brute Force with Two Pointers
+# 포인터를 사용해서 merge 해야하는 구간을 확인한다
+# 효율적이지 않아서 더 나은 방법이 있을 거 같다. 해당 문제를 봤을때 일단 기본적으로 정렬을 하고 pointer를 사용하는 방법을 떠올렸다.
+# merge 해야하는 구간은 2가지가 있다. 1. left의 end가 right의 start보다 크거나 같은 경우 2. left가 right의 구간을 전체를 다 포함하는경우 , 이경우 right를 지운다.
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        # Use two pointers
+        intervals = sorted(intervals)
+        left, right = 0, 1 
+        n = len(intervals)
+        while left < right and right < n:
+            if intervals[left][1] >= intervals[right][0] and intervals[left][1] >= intervals[right][1]:
+                del intervals[right]
+                n = len(intervals)
+             # and intervals[left][1] < intervals[right][1]
+            elif intervals[left][1] >= intervals[right][0]:
+                intervals[left] = [intervals[left][0], intervals[right][1]]
+                del intervals[right]
+                n = len(intervals)
+            # merge 할 경우가 아니면 다음 인덱스로 넘어가서 새로 비교한다 
+            else:
+                left += 1 
+                right += 1
+        return intervals 
+
+        # Optimized Solution 
+        intervals.sort(key=lambda interval: interval[0])
+        merged = []
+
+        for interval in intervals:
+            if not merged or merged[-1][1] < interval[0]:
+                merged.append(interval)
+            else:
+                merged[-1] = [merged[-1][0], max(merged[-1][1], interval[1])]
+        
+        return merged

missing-number/doh6077.py

@@ -0,0 +1,16 @@
+# Missing Number
+class Solution:
+    def missingNumber(self, nums: List[int]) -> int:
+        # First Solution: Time Complexity: O(n^2)
+        n = len(nums)
+
+        for i in range(0,n + 1):
+            if i not in nums:
+                return i    
+            
+        # Time Complexity: O(n) 
+        n = len(nums)
+        # calculate the sum of first n numbers
+        sum_val = n * (n + 1) // 2
+        return sum_val - sum(nums)
+

reorder-list/doh6077.py

@@ -0,0 +1,42 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def reorderList(self, head: Optional[ListNode]) -> None:
+        """
+        Do not return anything, modify head in-place instead.
+        """
+        # Time Complexity: O(N)
+        # The order: 
+        # 0, n, 1, n -1, 2, n-3 ...
+        # first Idea
+        # need to save the index of the original head 
+        # Hashmap: iterate through the head until head it none, save index as key and head.val as value 
+        head_hash = {}
+        temp = head
+        index = 0 
+        length = 0 
+        # Save index and value in the hashmap
+        while temp is not None:
+            head_hash[index] = temp.val
+            temp = temp.next 
+            index += 1
+            length += 1
+        # reset index to 0, and use it to iterate through the head again
+        index = 0 
+        # to keep track of n-1, n-2, n-3 ...
+        count = 1
+        # Iterate through the head again and change the value based on the index
+        while head is not None: 
+            res = index % 2 
+            # if the index is even number 
+            if res == 0:
+                head.val = head_hash[index/2]
+            # n, n-1, n-2 when the index is odd 
+            else:
+                head.val = head_hash[length - count]
+                count += 1 
+            index += 1
+            head = head.next