[Jeehay28] WEEK 10

course-schedule/Jeehay28.js

@@ -0,0 +1,69 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+
+// ✅ Graph DFS (Depth-First Search) approach
+// Time Complexity: O(V + E), where V is the number of courses (numCourses) and E is the number of prerequisites (edges).
+// Space Complexity: O(V + E), where V is the number of courses and E is the number of prerequisites.
+
+var canFinish = function (numCourses, prerequisites) {
+  // prerequisites = [
+  // [1, 0], // Course 1 depends on Course 0
+  // [2, 1], // Course 2 depends on Course 1
+  // [3, 1], // Course 3 depends on Course 1
+  // [3, 2]  // Course 3 depends on Course 2
+  // ];
+
+  // graph = {
+  // 0: [1], // Course 0 is a prerequisite for Course 1
+  // 1: [2, 3], // Course 1 is a prerequisite for Courses 2 and 3
+  // 2: [3], // Course 2 is a prerequisite for Course 3
+  // 3: [] // Course 3 has no prerequisites
+  // };
+
+  // Build the graph
+  const graph = {};
+
+  // for(let i=0; i<numCourses; i++) {
+  //     graph[i] = []
+  // }
+
+  // Fill in the graph with prerequisites
+  for (const [course, prereq] of prerequisites) {
+    if (!graph[prereq]) {
+      graph[prereq] = [];
+    }
+    graph[prereq].push(course);
+  }
+
+  const visited = new Array(numCourses).fill(0);
+
+  const dfs = (course) => {
+    if (visited[course] === 1) return false; // cycle detected!
+    if (visited[course] === 2) return true; // already visited
+
+    visited[course] = 1;
+
+    // // Visit all the courses that depend on the current course
+    for (const nextCourse of graph[course] || []) {
+      if (!dfs(nextCourse)) {
+        return false; // cycle detected!
+      }
+    }
+
+    visited[course] = 2; // fully visited and return true
+    return true;
+  };
+
+  // Check for each course whether it's possible to finish it
+  for (let i = 0; i < numCourses; i++) {
+    if (!dfs(i)) {
+      return false; // cycle detected!
+    }
+  }
+
+  return true; // no cycles
+};
+

invert-binary-tree/Jeehay28.js

@@ -0,0 +1,91 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+
+// ✔️ Recursive Approach
+// Time Complexity: O(N), N = Total number of nodes (each node is processed once)
+// Space Complexity: O(H), H = Height of the tree (due to recursion stack depth)
+
+var invertTree = function (root) {
+  if (!root) return null;
+
+  [root.left, root.right] = [root.right, root.left];
+
+  invertTree(root.left);
+  invertTree(root.right);
+
+  return root;
+};
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+
+// ✔️ Stack → DFS approach
+// Time Complexity: O(N), N = Total number of nodes (each node is processed once)
+// Space Complexity: O(H), H = Height of the tree (due to recursion stack depth)
+
+// var invertTree = function (root) {
+//   let stack = [root];
+
+//   while (stack.length > 0) {
+//     const node = stack.pop();
+//     if (!node) continue;
+
+//     [node.left, node.right] = [node.right, node.left];
+//     stack.push(node.left);
+//     stack.push(node.right);
+//   }
+//   return root;
+// };
+
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+
+// ✔️ Queue → BFS
+// Time Complexity: O(N), N = Total number of nodes (each node is processed once)
+// Space Complexity: O(W), W = Maximum width of the tree
+// var invertTree = function (root) {
+//   let queue = [root];
+
+//   while (queue.length > 0) {
+//     const node = queue.shift();
+//     if (!node) continue;
+
+//     [node.left, node.right] = [node.right, node.left];
+//     queue.push(node.left);
+//     queue.push(node.right);
+//   }
+//   return root;
+// };
+
+

search-in-rotated-sorted-array/Jeehay28.js

@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+
+// ✅ Iterative Binary Search for Rotated Sorted Array
+// Time Complexity: O(log N)
+// Space Complexity: O(1)
+var search = function (nums, target) {
+  let left = 0;
+  let right = nums.length - 1;
+
+  while (left <= right) {
+    let pointer = Math.floor((left + right) / 2);
+
+    if (nums[pointer] === target) {
+      return pointer;
+    }
+
+    // Check if the left half is sorted
+    if (nums[left] <= nums[pointer]) {
+      // Target is in the sorted left half
+      if (nums[left] <= target && target < nums[pointer]) {
+        right = pointer - 1;
+      } else {
+        // Target is not in the left half, so search in the right half
+        left = pointer + 1;
+      }
+    } else {
+      // The right half must be sorted
+
+      // Target is in the sorted right half
+      if (nums[pointer] < target && target <= nums[right]) {
+        left = pointer + 1;
+      } else {
+        // Target is not in the right half, so search in the left half
+        right = pointer - 1;
+      }
+    }
+  }
+
+  return -1;
+};
+