[hoyeongkwak] Week 11 Solutions

binary-tree-maximum-path-sum/hoyeongkwak.ts

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+/*
+Time complexity: O(N)
+Space complexity: O(N) h: 트리의 높이
+*/
+function maxPathSum(root: TreeNode | null): number {
+    let maxSum = -Infinity
+    const dfs = (node: TreeNode): number => {
+        if (node == null) return 0
+
+        const leftMax = Math.max(0, dfs(node.left))
+        const rightMax = Math.max(0, dfs(node.right))
+        const currentMax = node.val + leftMax + rightMax
+
+        maxSum = Math.max(maxSum, currentMax)
+        return node.val + Math.max(leftMax, rightMax)
+    }
+    dfs(root)
+    return maxSum
+};

merge-intervals/hoyeongkwak.ts

@@ -0,0 +1,17 @@
+/*
+Time complexity: O(NlogN)
+Space complexity: O(N)
+*/
+function merge(intervals: number[][]): number[][] {
+    if (intervals.length === 0) return intervals
+    intervals.sort((a, b) => a[0] - b[0])
+    const result = []
+    for (const interval of intervals) {
+        if (result.length === 0 || result[result.length - 1][1] < interval[0]) {
+            result.push(interval)
+        } else {
+            result[result.length - 1][1] = Math.max(result[result.length -1][1], interval[1])
+        }
+    }
+    return result
+};

missing-number/hoyeongkwak.ts

@@ -0,0 +1,15 @@
+/*
+Time complexity: O(N)
+Space complexity: O(N)
+*/
+function missingNumber(nums: number[]): number {
+    const numSet = new Set<number>(nums)
+    let missNum = 0
+    for (let i = 0; i <= nums.length; i++) {
+        if (!numSet.has(i)) {
+            missNum = i
+            break
+        }
+    }
+    return missNum
+};

reorder-list/hoyeongkwak.ts

@@ -0,0 +1,48 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+/**
+ Do not return anything, modify head in-place instead.
+ */
+ /*
+Time complexity: O(N)
+Space complexity: O(1)
+*/
+function reorderList(head: ListNode | null): void {
+    let slow = head
+    let fast = head
+    while (fast && fast.next) {
+        slow = slow.next
+        fast = fast.next.next
+    }
+    let curr = slow.next
+    slow.next = null
+    let prev = null
+
+    while (curr) {
+        let temp = curr.next
+        curr.next = prev
+        prev = curr
+        curr = temp
+    }
+    let first = head
+    let second = prev
+
+    while (second) {
+        let firstNext = first.next
+        let secondNext = second.next
+        first.next = second
+        second.next = firstNext
+        first = firstNext
+        second = secondNext
+    }
+};