[Jeehay28] WEEK 11 Solutions

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

@@ -0,0 +1,30 @@
+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;
+  }
+}
+
+// TC: O(n)
+// SC: O(n)
+function maxPathSum(root: TreeNode | null): number {
+  let maxSum = -Infinity;
+
+  const dfs = (node: TreeNode | null) => {
+    if (!node) return 0;
+
+    const leftMax = Math.max(dfs(node.left), 0);
+    const rightMax = Math.max(dfs(node.right), 0);
+
+    maxSum = Math.max(node.val + leftMax + rightMax, maxSum);
+
+    return node.val + Math.max(leftMax, rightMax);
+  };
+
+  dfs(root);
+  return maxSum;
+}

merge-intervals/Jeehay28.ts

@@ -0,0 +1,22 @@
+// TC: O(n * log n)
+// SC: O(n)
+function merge(intervals: number[][]): number[][] {
+  if (intervals.length === 0) return [];
+
+  intervals.sort((a, b) => a[0] - b[0]);
+
+  const merged = [intervals[0]];
+
+  for (let i = 1; i < intervals.length; i++) {
+    const last = merged[merged.length - 1];
+    const current = intervals[i];
+
+    if (current[0] <= last[1]) {
+      last[1] = Math.max(last[1], current[1]);
+    } else {
+      merged.push(intervals[i]);
+    }
+  }
+
+  return merged;
+}

missing-number/Jeehay28.ts

@@ -0,0 +1,30 @@
+// TC: O(n)
+// SC: O(1)
+function missingNumber(nums: number[]): number {
+  // 0, 1, 2, 3 => n * (n + 1) / 2
+
+  let sum = (nums.length * (nums.length + 1)) / 2;
+
+  for (const num of nums) {
+    sum -= num;
+  }
+
+  return sum;
+}
+
+
+// TC: O(n)
+// SC: (1)
+// function missingNumber(nums: number[]): number {
+//   let xor = 0;
+
+//   for (let i = 0; i <= nums.length; i++) {
+//     xor ^= i;
+//   }
+
+//   for (const num of nums) {
+//     xor ^= num;
+//   }
+
+//   return xor;
+// }

reorder-list/Jeehay28.ts

@@ -0,0 +1,36 @@
+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.
+ */
+
+// TC: O(n)
+// SC: O(n)
+function reorderList(head: ListNode | null): void {
+  const nodes: ListNode[] = [];
+
+  while (head) {
+    nodes.push(head);
+    head = head.next;
+  }
+
+  let start = 0;
+  let end = nodes.length - 1;
+
+  while (start < end) {
+    nodes[start].next = nodes[end];
+    start++;
+    if (start === end) break;
+    nodes[end].next = nodes[start];
+    end--;
+  }
+
+  nodes[start].next = null;
+}