[선재] WEEK10 Solutions

course-schedule/sunjae95.js

@@ -0,0 +1,47 @@
+/**
+ * @description
+ * memoization + dfs
+ *
+ * n = length of nums
+ * p = length of prerequisites
+ *
+ * time complexity: O(n)
+ * space complexity: O(p)
+ */
+var canFinish = function (numCourses, prerequisites) {
+  const memo = Array.from({ length: numCourses + 1 }, () => false);
+  const visited = Array.from({ length: numCourses + 1 }, () => false);
+  // graph setting
+  const graph = prerequisites.reduce((map, [linkedNode, current]) => {
+    const list = map.get(current) ?? [];
+    list.push(linkedNode);
+    map.set(current, list);
+    return map;
+  }, new Map());
+
+  const dfs = (current) => {
+    const linkedNode = graph.get(current);
+
+    if (memo[current] || !linkedNode || linkedNode.length === 0) return true;
+
+    for (const node of linkedNode) {
+      if (visited[node]) return false;
+
+      visited[node] = true;
+      if (!dfs(node)) return false;
+      visited[node] = false;
+      memo[node] = true;
+    }
+
+    return true;
+  };
+
+  for (const [current] of graph) {
+    visited[current] = true;
+    if (!dfs(current)) return false;
+    visited[current] = false;
+    memo[current] = true;
+  }
+
+  return true;
+};

invert-binary-tree/sunjae95.js

@@ -0,0 +1,23 @@
+/**
+ * @description
+ * brainstorming:
+ * preorder traverse
+ *
+ * n = length of root
+ * time complexity: O(n)
+ * space complexity: O(n)
+ */
+var invertTree = function (root) {
+  const preOrder = (tree) => {
+    if (tree === null) return null;
+
+    const currentNode = new TreeNode(tree.val);
+
+    currentNode.right = preOrder(tree.left);
+    currentNode.left = preOrder(tree.right);
+
+    return currentNode;
+  };
+
+  return preOrder(root);
+};

jump-game/sunjae95.js

@@ -0,0 +1,17 @@
+/**
+ * @description
+ *
+ * n = length of nums
+ * time complexity: O(n)
+ * space complexity: O(1)
+ */
+var canJump = function (nums) {
+  let cur = 1;
+  for (const num of nums) {
+    if (cur === 0) return false;
+    cur--;
+    cur = cur > num ? cur : num;
+  }
+
+  return true;
+};

merge-k-sorted-lists/sunjae95.js

@@ -0,0 +1,43 @@
+/**
+ * @description
+ * queue의 특성을 활용하여 풀이
+ *
+ * n = length of lists
+ * m = length of lists[i]
+ * time complexity: O(n * n * m)
+ * space complexity: O(n*m)
+ */
+var mergeKLists = function (lists) {
+  let answer = null;
+  let tail = null;
+  let totalSize = lists.reduce((size, list) => {
+    let head = list;
+    let count = 0;
+
+    while (head) {
+      head = head.next;
+      count++;
+    }
+
+    return size + count;
+  }, 0);
+
+  while (totalSize--) {
+    let minIndex = lists.reduce((acc, list, i) => {
+      if (list === null) return acc;
+      if (acc === null) return { value: list.val, index: i };
+      return acc.value < list.val ? acc : { value: list.val, index: i };
+    }, null).index;
+
+    if (answer === null) {
+      answer = lists[minIndex];
+      tail = answer;
+    } else {
+      tail.next = lists[minIndex];
+      tail = lists[minIndex];
+    }
+
+    lists[minIndex] = lists[minIndex].next;
+  }
+  return answer;
+};

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

@@ -0,0 +1,22 @@
+/**
+ * @description
+ * https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/
+ * n = length of nums
+ * time complexity: O(n)
+ * space complexity: O(1)
+ */
+var search = function (nums, target) {
+  let [start, end] = [0, nums.length - 1];
+  let answer = -1;
+
+  while (start !== end) {
+    if (nums[start] === target) answer = start;
+    if (nums[end] === target) answer = end;
+    if (nums[start] > nums[end]) end--;
+    else start++;
+  }
+
+  if (nums[start] === target) answer = start;
+
+  return answer;
+};