[hyer0705] Week 12 solution

non-overlapping-intervals/hyer0705.ts

@@ -0,0 +1,18 @@
+function eraseOverlapIntervals(intervals: number[][]): number {
+  intervals.sort((a, b) => a[1] - b[1]);
+
+  let removedCount = 0;
+  let prevEnd = intervals[0][1];
+
+  for (let i = 1; i < intervals.length; i++) {
+    const [start, end] = intervals[i];
+
+    if (prevEnd > start) {
+      removedCount++;
+    } else {
+      prevEnd = end;
+    }
+  }
+
+  return removedCount;
+}

number-of-connected-components-in-an-undirected-graph/hyer0705.ts

@@ -0,0 +1,36 @@
+export class Solution {
+  /**
+   * @param n: the number of vertices
+   * @param edges: the edges of undirected graph
+   * @return: the number of connected components
+   */
+  countComponents(n: number, edges: number[][]): number {
+    const parent = Array.from({ length: n }, (_, i) => i);
+    let components = n;
+
+    const find = (i: number): number => {
+      if (parent[i] === i) {
+        return i;
+      }
+
+      parent[i] = find(parent[i]);
+      return parent[i];
+    };
+
+    const union = (a: number, b: number): void => {
+      const rootA = find(a);
+      const rootB = find(b);
+
+      if (rootA !== rootB) {
+        parent[rootA] = rootB;
+        components--;
+      }
+    };
+
+    for (const [a, b] of edges) {
+      union(a, b);
+    }
+
+    return components;
+  }
+}

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

@@ -0,0 +1,34 @@
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+  if (!head) return null;
+
+  let current = head;
+  let nodeLen = 0;
+  while (current.next) {
+    current = current.next;
+    nodeLen++;
+  }
+
+  if (nodeLen - n < 0) return head.next;
+
+  current = head;
+  let count = 0;
+  while (count < nodeLen - n) {
+    current = current.next;
+    count++;
+  }
+  current.next = current.next.next;
+
+  return head;
+}

same-tree/hyer0705.ts

@@ -0,0 +1,21 @@
+/**
+ * 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)
+ *     }
+ * }
+ */
+
+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);
+}

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

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