[hyer0705] WEEK 10 solutions

course-schedule/hyer0705.ts

@@ -0,0 +1,34 @@
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+  const graph: number[][] = Array.from({ length: numCourses }, () => []);
+  const inDegree: number[] = Array(numCourses).fill(0);
+
+  for (const [course, prerequisite] of prerequisites) {
+    graph[prerequisite].push(course);
+    inDegree[course]++;
+  }
+
+  // 지금 당장 수강할 수 있는 과목 목록
+  const queue: number[] = [];
+
+  for (let i = 0; i < numCourses; i++) {
+    if (inDegree[i] === 0) {
+      queue.push(i);
+    }
+  }
+
+  const result: number[] = [];
+  while (queue.length > 0) {
+    const course = queue.shift()!;
+    result.push(course);
+
+    for (const nextCourse of graph[course]) {
+      inDegree[nextCourse]--;
+      if (inDegree[nextCourse] === 0) {
+        queue.push(nextCourse);
+      }
+    }
+  }
+
+  if (result.length !== numCourses) return false;
+  return true;
+}

invert-binary-tree/hyer0705.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 invertTree(root: TreeNode | null): TreeNode | null {
+  if (!root) return null;
+
+  const temp = root.left;
+  root.left = root.right;
+  root.right = temp;
+
+  invertTree(root.left);
+  invertTree(root.right);
+
+  return root;
+}

jump-game/hyer0705.ts

@@ -0,0 +1,13 @@
+function canJump(nums: number[]): boolean {
+  const n = nums.length;
+
+  let maximumReach = 0;
+
+  for (let i = 0; i < n; i++) {
+    if (i > maximumReach) return false;
+
+    maximumReach = Math.max(maximumReach, i + nums[i]);
+  }
+
+  return maximumReach >= n - 1;
+}

merge-k-sorted-lists/hyer0705.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 mergeKLists(lists: Array<ListNode | null>): ListNode | null {
+  if (!lists || lists.length === 0) return null;
+
+  const minHeap = new PriorityQueue((a: ListNode, b: ListNode) => a.val - b.val);
+
+  for (const node of lists) {
+    if (node) minHeap.enqueue(node);
+  }
+
+  const dummyHead = new ListNode();
+  let current = dummyHead;
+
+  while (!minHeap.isEmpty()) {
+    const minimumElement = minHeap.dequeue();
+
+    current.next = minimumElement;
+    current = current.next;
+
+    if (minimumElement.next) {
+      minHeap.enqueue(minimumElement.next);
+    }
+  }
+
+  return dummyHead.next;
+}

search-in-rotated-sorted-array/hyer0705.ts

@@ -0,0 +1,26 @@
+function search(nums: number[], target: number): number {
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+
+    if (nums[mid] === target) return mid;
+
+    if (nums[mid] >= nums[left]) {
+      if (target < nums[mid] && target >= nums[left]) {
+        right = mid - 1;
+      } else {
+        left = mid + 1;
+      }
+    } else {
+      if (target > nums[mid] && target <= nums[right]) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+  }
+
+  return -1;
+}