[Jeehay28] WEEK 12 Solutions

non-overlapping-intervals/Jeehay28.ts

@@ -0,0 +1,46 @@
+// TC: O(n log n)
+// SC: O(1)
+function eraseOverlapIntervals(intervals: number[][]): number {
+  intervals.sort((a, b) => a[1] - b[1]);
+  // [1, 2], [2, 3], [1, 3], [3, 4]
+
+  let prevEnd = intervals[0][1];
+  let removalCount = 0;
+
+  for (let i = 1; i < intervals.length; i++) {
+    if (prevEnd > intervals[i][0]) {
+      removalCount++;
+      // skip current interval
+    } else {
+      prevEnd = intervals[i][1];
+    }
+  }
+
+  return removalCount;
+}
+
+
+// TC: O(n log n)
+// SC: O(1)
+// function eraseOverlapIntervals(intervals: number[][]): number {
+//   intervals.sort((a, b) => a[0] - b[0]);
+
+//   let prev = intervals[0];
+//   let cnt = 1;
+//   let removalCount = 0;
+
+//   while (cnt < intervals.length) {
+//     const current = intervals[cnt];
+
+//     if (prev[1] <= current[0]) {
+//       prev = current;
+//     } else {
+//       prev = [Math.min(prev[0], current[0]), Math.min(prev[1], current[1])];
+//       removalCount++;
+//     }
+//     cnt++;
+//   }
+
+//   return removalCount;
+// }
+

remove-nth-node-from-end-of-list/Jeehay28.ts

@@ -0,0 +1,60 @@
+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;
+  }
+}
+
+// TC: O(n)
+// SC: O(1)
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+  let dummy = new ListNode();
+  dummy.next = head;
+  let fast: ListNode | null = dummy;
+  let slow: ListNode | null = dummy;
+
+  for (let i = 0; i < n + 1; i++) {
+    if (fast) {
+      fast = fast.next;
+    }
+  }
+
+  while (fast) {
+    fast = fast.next;
+    slow = slow!.next;
+  }
+
+  if (slow && slow.next) {
+    slow.next = slow.next.next;
+  }
+
+  return dummy.next;
+}
+
+
+// TC: O(n)
+// SC: O(n)
+// function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+//   let dummy = head;
+//   const nodes: (ListNode | null)[] = [];
+
+//   while (dummy) {
+//     nodes.push(dummy);
+//     dummy = dummy.next;
+//   }
+
+//   // first node: nodes.length === n
+//   // last node: n === 1
+
+//   if (nodes.length === n) {
+//     head = head!.next;
+//   } else if (nodes.length > 1 && n === 1) {
+//     nodes[nodes.length - 2]!.next = null;
+//   } else {
+//     nodes[nodes.length - n - 1]!.next = nodes[nodes.length - n + 1];
+//   }
+
+//   return head;
+// }

same-tree/Jeehay28.ts

@@ -0,0 +1,41 @@
+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 isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
+  if (!p && !q) return true;
+  if (!p || !q) return false;
+
+  if (p.val !== q.val) return false;
+
+  return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+}
+
+
+// TC: O(n)
+// SC: O(n)
+// function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
+//   const stack: (TreeNode | null)[][] = [[p, q]];
+
+//   while (stack.length > 0) {
+//     const [node1, node2] = stack.pop();
+
+//     if (!node1 && !node2) continue;
+//     if (!node1 || !node2) return false;
+//     if (node1.val !== node2.val) return false;
+
+//     stack.push([node1.left, node2.left]);
+//     stack.push([node1.right, node2.right]);
+//   }
+
+//   return true;
+// }

serialize-and-deserialize-binary-tree/Jeehay28.ts

@@ -0,0 +1,52 @@
+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;
+  }
+}
+
+/*
+ * Encodes a tree to a single string.
+ */
+
+// TC: O(n)
+// SC: O(n)
+function serialize(root: TreeNode | null): string {
+  if (!root) return "null";
+  return `${root.val},${serialize(root.left)},${serialize(root.right)}`;
+}
+
+/*
+ * Decodes your encoded data to tree.
+ */
+
+// TC: O(n)
+// SC: O(n)
+function deserialize(data: string): TreeNode | null {
+  const values = data.split(",");
+  let idx = 0;
+
+  const dfs = () => {
+    if (values[idx] === "null") {
+      idx++;
+      return null;
+    }
+
+    const node = new TreeNode(parseInt(values[idx]));
+    idx++;
+    node.left = dfs();
+    node.right = dfs();
+    return node;
+  };
+
+  return dfs();
+}
+
+/**
+ * Your functions will be called as such:
+ * deserialize(serialize(root));
+ */