[hsskey] Week 10 Solutions

course-schedule/hsskey.js

@@ -0,0 +1,37 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+var canFinish = function(numCourses, prerequisites) {
+    const preMap = {};
+    for (let i = 0; i < numCourses; i++) {
+        preMap[i] = [];
+    }
+    for (const [crs, pre] of prerequisites) {
+        preMap[crs].push(pre);
+    }
+
+    const visitSet = new Set();
+
+    const dfs = (crs) => {
+        if (visitSet.has(crs)) return false;
+        if (preMap[crs].length === 0) return true;
+
+        visitSet.add(crs);
+        for (const pre of preMap[crs]) {
+            if (!dfs(pre)) return false;
+        }
+        visitSet.delete(crs);
+        preMap[crs] = [];
+
+        return true;
+    };
+
+    for (let crs = 0; crs < numCourses; crs++) {
+        if (!dfs(crs)) return false;
+    }
+
+    return true;
+};
+

invert-binary-tree/hsskey.js

@@ -0,0 +1,27 @@
+/**
+ * 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}
+ */
+var invertTree = function(root) {
+    if (!root) return null;
+
+    // swap the children
+    let tmp = root.left;
+    root.left = root.right;
+    root.right = tmp;
+
+    invertTree(root.left);
+    invertTree(root.right);
+
+    return root;
+};
+

jump-game/hsskey.js

@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var canJump = function(nums) {
+    let goal = nums.length - 1;
+
+    for (let i = nums.length - 1; i >= 0; i--) {
+        if (i + nums[i] >= goal) {
+            goal = i;
+        }
+    }
+
+    return goal === 0;
+};
+

merge-k-sorted-lists/hsskey.js

@@ -0,0 +1,49 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+
+/**
+ * @param {ListNode[]} lists
+ * @return {ListNode}
+ */
+var mergeKLists = function(lists) {
+    if (!lists || lists.length === 0) return null;
+
+    const mergeList = (l1, l2) => {
+        const dummy = new ListNode(0);
+        let current = dummy;
+
+        while (l1 && l2) {
+            if (l1.val < l2.val) {
+                current.next = l1;
+                l1 = l1.next;
+            } else {
+                current.next = l2;
+                l2 = l2.next;
+            }
+            current = current.next;
+        }
+
+        current.next = l1 || l2;
+        return dummy.next;
+    };
+
+    while (lists.length > 1) {
+        const mergedLists = [];
+
+        for (let i = 0; i < lists.length; i += 2) {
+            const l1 = lists[i];
+            const l2 = (i + 1 < lists.length) ? lists[i + 1] : null;
+            mergedLists.push(mergeList(l1, l2));
+        }
+
+        lists = mergedLists;
+    }
+
+    return lists[0];
+};
+

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

@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function(nums, target) {
+    let l = 0, r = nums.length - 1;
+
+    while (l <= r) {
+        const mid = Math.floor((l + r) / 2);
+
+        if (nums[mid] === target) {
+            return mid;
+        }
+
+        // left sorted portion
+        if (nums[l] <= nums[mid]) {
+            if (target > nums[mid] || target < nums[l]) {
+                l = mid + 1;
+            } else {
+                r = mid - 1;
+            }
+        }
+        // right sorted portion
+        else {
+            if (target < nums[mid] || target > nums[r]) {
+                r = mid - 1;
+            } else {
+                l = mid + 1;
+            }
+        }
+    }
+
+    return -1;
+};
+