Merge pull request #532 from HC-kang/main

[강희찬] WEEK 10 Solution

Author: HC-kang

course-schedule/HC-kang.ts

@@ -0,0 +1,34 @@
+/**
+ * https://leetcode.com/problems/course-schedule/
+ * T.C. O(V + E)
+ * S.C. O(V + E)
+ */
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+  const graph: number[][] = Array.from({ length: numCourses }, () => []);
+  for (const [course, pre] of prerequisites) {
+    graph[pre].push(course);
+  }
+
+  const visited = new Array(numCourses).fill(false);
+  const visiting = new Array(numCourses).fill(false);
+
+  const dfs = (course: number): boolean => {
+    if (visited[course]) return true;
+    if (visiting[course]) return false;
+
+    visiting[course] = true;
+    for (const neighbor of graph[course]) {
+      if (!dfs(neighbor)) return false;
+    }
+    visiting[course] = false;
+    visited[course] = true;
+
+    return true;
+  };
+
+  for (let i = 0; i < numCourses; i++) {
+    if (!visited[i] && !dfs(i)) return false;
+  }
+
+  return true;
+}

invert-binary-tree/HC-kang.ts

@@ -0,0 +1,48 @@
+// 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;
+//   }
+// }
+
+/**
+ * https://leetcode.com/problems/invert-binary-tree
+ * T.C. O(n)
+ * S.C. O(n)
+ */
+function invertTree(root: TreeNode | null): TreeNode | null {
+  if (root === null) {
+    return null;
+  }
+
+  [root.left, root.right] = [root.right, root.left];
+  invertTree(root.left);
+  invertTree(root.right);
+
+  return root;
+}
+
+/**
+ * T.C. O(n)
+ * S.C. O(n)
+ */
+function invertTree(root: TreeNode | null): TreeNode | null {
+  const stack: Array<TreeNode | null> = [root];
+
+  while (stack.length > 0) {
+    const node = stack.pop()!;
+
+    if (node === null) {
+      continue;
+    }
+
+    [node.left, node.right] = [node.right, node.left];
+    stack.push(node.left, node.right);
+  }
+
+  return root;
+}

jump-game/HC-kang.ts

@@ -0,0 +1,16 @@
+/**
+ * https://leetcode.com/problems/jump-game/
+ * T.C. O(n)
+ * S.C. O(1)
+ */
+function canJump(nums: number[]): boolean {
+  let max = 0;
+
+  for (let i = 0; i < nums.length; i++) {
+    if (i > max) return false;
+    max = Math.max(max, i + nums[i]);
+    if (max >= nums.length - 1) return true;
+  }
+
+  return false;
+}

merge-k-sorted-lists/HC-kang.ts

@@ -0,0 +1,39 @@
+// 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-k-sorted-lists
+ * T.C. O(n * k^2) n: average length of list, k: number of lists
+ * S.C. O(1)
+ */
+function mergeKLists(lists: Array<ListNode | null>): ListNode | null {
+  if (lists.length === 0) return null;
+  if (lists.length === 1) return lists[0];
+  return lists.reduce((acc, cur) => mergeTwoLists(acc, cur), null);
+
+  function mergeTwoLists(list1: ListNode | null, list2: ListNode | null): ListNode | null {
+    const 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;
+  }
+}

search-in-rotated-sorted-array/HC-kang.ts

@@ -0,0 +1,32 @@
+/**
+ * https://leetcode.com/problems/search-in-rotated-sorted-array
+ * T.C. O(log n)
+ * S.C. O(1)
+ */
+function search(nums: number[], target: number): number {
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left <= right) {
+    let mid = left + ((right - left) >> 1);
+
+    if (nums[mid] === target) {
+      return mid;
+    }
+
+    if (nums[left] <= nums[mid]) {
+      if (nums[left] <= target && target < nums[mid]) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
+    } else {
+      if (nums[mid] < target && target <= nums[right]) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+  }
+  return -1;
+}