Merge pull request #502 from HC-kang/main

[강희찬] WEEK 8 Solution

clone-graph/HC-kang.ts

@@ -0,0 +1,63 @@
+/**
+ * https://leetcode.com/problems/clone-graph
+ * T.C. O(N)
+ * S.C. O(N)
+ */
+function cloneGraph(node: _Node | null): _Node | null {
+  if (!node) return null;
+
+  const map = new Map<number, _Node>();
+  return dfs(node);
+
+  function dfs(node: _Node): _Node {
+    if (map.has(node.val)) return map.get(node.val)!;
+
+    const newNode = new _Node(node.val);
+    map.set(node.val, newNode);
+
+    for (let neighbor of node.neighbors) {
+      newNode.neighbors.push(dfs(neighbor));
+    }
+
+    return newNode;
+  }
+}
+
+/**
+ * T.C. O(N)
+ * S.C. O(N)
+ */
+function cloneGraph(node: _Node | null): _Node | null {
+  if (!node) return null;
+
+  const map = new Map<number, _Node>();
+  const stack = [node];
+  const newNode = new _Node(node.val);
+  map.set(node.val, newNode);
+
+  while (stack.length) {
+    const node = stack.pop()!;
+    const newNode = map.get(node.val)!;
+
+    for (let neighbor of node.neighbors) {
+      if (!map.has(neighbor.val)) {
+        stack.push(neighbor);
+        const newNeighbor = new _Node(neighbor.val);
+        map.set(neighbor.val, newNeighbor);
+      }
+      newNode.neighbors.push(map.get(neighbor.val)!);
+    }
+  }
+
+  return newNode;
+}
+
+class _Node {
+  val: number;
+  neighbors: _Node[];
+
+  constructor(val?: number, neighbors?: _Node[]) {
+    this.val = val === undefined ? 0 : val;
+    this.neighbors = neighbors === undefined ? [] : neighbors;
+  }
+}

longest-common-subsequence/HC-kang.ts

@@ -0,0 +1,23 @@
+/**
+ * https://leetcode.com/problems/longest-common-subsequence
+ * T.C. O(m * n)
+ * S.C. O(n)
+ */
+function longestCommonSubsequence(text1: string, text2: string): number {
+  const dp = Array.from({ length: text2.length + 1 }, () => 0);
+
+  for (let i = 1; i <= text1.length; i++) {
+    let prev = 0;
+    for (let j = 1; j <= text2.length; j++) {
+      const temp = dp[j];
+      if (text1[i - 1] === text2[j - 1]) {
+        dp[j] = prev + 1;
+      } else {
+        dp[j] = Math.max(dp[j], dp[j - 1]);
+      }
+      prev = temp;
+    }
+  }
+
+  return dp[text2.length];
+}

longest-repeating-character-replacement/HC-kang.ts

@@ -0,0 +1,25 @@
+/**
+ * https://leetcode.com/problems/longest-repeating-character-replacement
+ * T.C. O(n)
+ * S.C. O(1)
+ */
+function characterReplacement(s: string, k: number): number {
+  const charCount = new Array(26).fill(0);
+  let maxCount = 0;
+  let start = 0;
+  let maxLen = 0;
+
+  const A = 'A'.charCodeAt(0);
+  for (let end = 0; end < s.length; end++) {
+    const endCharIdx = s.charCodeAt(end) - A;
+    maxCount = Math.max(maxCount, ++charCount[endCharIdx]);
+
+    if (end - start + 1 - maxCount > k) {
+      charCount[s.charCodeAt(start) - A]--;
+      start++;
+    }
+
+    maxLen = Math.max(maxLen, end - start + 1);
+  }
+  return maxLen;
+}

merge-two-sorted-lists/HC-kang.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;
+  }
+}
+
+/**
+ * https://leetcode.com/problems/merge-two-sorted-lists
+ * T.C. O(m + n)
+ * S.C. O(1)
+ */
+function mergeTwoLists(
+  list1: ListNode | null,
+  list2: ListNode | null
+): ListNode | null {
+  let head = new ListNode();
+  let current = head;
+
+  while (list1 && list2) {
+    if (list1.val < list2.val) {
+      current.next = list1;
+      list1 = list1.next;
+    } else {
+      current.next = list2;
+      list2 = list2.next;
+    }
+    current = current.next;
+  }
+
+  current.next = list1 || list2;
+
+  return head.next;
+}

sum-of-two-integers/HC-kang.ts

@@ -0,0 +1,13 @@
+/**
+ * https://leetcode.com/problems/sum-of-two-integers
+ * T.C. O(log a)
+ * S.C. O(1)
+ */
+function getSum(a: number, b: number): number {
+  while (b != 0) {
+    let carry = a & b;
+    a = a ^ b;
+    b = carry << 1;
+  }
+  return a;
+}