greedy jump games 41, 45

Author: jyxia

Hard/41-firstMissingPositive.js

@@ -0,0 +1,34 @@
+/**
+ * Solution: keep swapping elements until the element is in the right position.
+ * e.g. [3,1,2] --> [2,1,3] -> [1,2,3], now 1 is in the right position.
+ * special cases: the element is <=0, or is bigger the length of the array or
+ * there is a duplicate in the position at nums[i] - 1 stop swapping, otherewise,
+ * it will be an infinite loop.
+ * if every element is in the right position, then just simpily return the last element + 1
+ *
+ * @param {number[]} nums
+ * @return {number}
+ */
+var firstMissingPositive = function(nums) {
+    if (nums.length <= 0) return 1;
+    for (var i = 0; i < nums.length; i++) {
+        while (nums[i] !== i + 1) {
+            if (nums[i] <= 0) break;
+            if (nums[i] > nums.length - 1 || nums[nums[i] - 1] === nums[i]) break;
+            swap(nums, nums[i] - 1, i);
+        }
+    }
+    for (var j = 0; j < nums.length; j++) {
+        if (nums[j] !== j + 1) {
+            return j + 1;
+        }
+    }
+    // if every element is in the right position, then just simpily return the last element + 1
+    return nums[nums.length - 1] + 1;
+};
+
+var swap = function(nums, i, j) {
+    var tmp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = tmp;
+};

Hard/45-jumpGameII.js

@@ -0,0 +1,42 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var jump = function(nums) {
+    var jumpTo = 0;
+    var lastReach = 0;
+    var jumps = 0;
+    for (var i = 0; i < nums.length && i <= jumpTo; i++) {
+        //when last jump can not reach i, increase the step by 1
+        if (i > lastReach) {
+            jumps++;
+            lastReach = jumpTo;
+        }
+        jumpTo = Math.max(jumpTo, nums[i] + i);
+    }
+
+    return lastReach >= nums.length - 1 ? jumps : 0;
+};
+
+// second solution, easy understanding. Nice solution. BFS
+// [2,3,1,1,4] 2 -> 3, 1 -> 4
+var jump = function(nums) {
+    var curr = 0;
+    var next = 0;
+    var jumps = 0;
+    var length = nums.length;
+    for (var i = 0; i < length;) {
+        if (curr >= length - 1) break;
+        // find the next (max jump to) of every element before (including) current element
+        // once the next is chosen, it is one step jump.
+        while (i <= curr) {
+            next = Math.max(i + nums[i], next);
+            i++;
+        }
+
+        jumps++;
+        curr = next;
+    }
+
+    return jumps;
+};

Hard/57-insertInterval.js

@@ -6,6 +6,11 @@
  * }
  */
 /**
+ * Solutions: 3 scenarios,
+ * 1) [[1,2], [5,6]] insert [3,4], push [1,2] (first if),
+ * 2) continue step 1, push [3,4] (2nd if), push[5,6] (2nd if)
+ * 3) another example, [[1,3], [3,5]] insert [2,4]
+ *
  * @param {Interval[]} intervals
  * @param {Interval} newInterval
  * @return {Interval[]}
@@ -18,7 +23,8 @@ var insert = function(intervals, newInterval) {
         } else if (intervals[i].start > newInterval.end) {
             result.push(newInterval);
             newInterval = intervals[i];
-        } else if (intervals[i].end >= newInterval.start || intervals[i].start <= newInterval.end) {
+        } else {
+            // this case is (intervals[i].end >= newInterval.start || intervals[i].start <= newInterval.end)
             newInterval.start = Math.min(intervals[i].start, newInterval.start);
             newInterval.end = Math.max(intervals[i].end, newInterval.end);
         }

Medium/55-jumpGame.js

@@ -1,6 +1,6 @@
 /**
  * Key: one scenario return false, is when you meet 0 and the max move can't reach to the end.
- * becaue no moves can be made when the element is 0. 
+ * becaue no moves can be made when the element is 0.
  *
  * @param {number[]} nums
  * @return {boolean}
@@ -14,3 +14,31 @@ var canJump = function(nums) {
 
     return true;
 };
+
+// second try, not good
+var canJump = function(nums) {
+    if (nums.length === 1) return true;
+    var maxJump = 0;
+    for (var i = 0; i < nums.length; i++) {
+        maxJump = Math.max(maxJump, nums[i] + i);
+        if (maxJump === i) return false;
+        if (maxJump >= nums.length - 1) return true;
+    }
+
+    return false;
+};
+
+var canJump = function(nums) {
+  if (nums.length < 1) return true;
+  var maxNextJump = nums[0];
+
+  for (var i = 1; i < nums.length; i++) {
+    // jumped one step
+    maxNextJump--;
+    if (maxNextJump < 0) return false;
+    // if steps at positin i is larger than maxNextJump, then nums[i] is the next jump steps.
+    if (maxNextJump < nums[i]) maxNextJump = nums[i];
+  }
+
+  return true;
+}

README.md

@@ -155,6 +155,8 @@
 * [25. Reverse Nodes in k-Group](https://leetcode.com/problems/reverse-nodes-in-k-group/) -  [Solution](./Hard/25-reverseNodesInKGroup.js)
 * [32. Longest Valid Parentheses](https://leetcode.com/problems/longest-valid-parentheses/) -  [Solution](./Hard/32-longestValidParentheses.js)
 * [33. Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array/) -  [Solution](./Hard/33-searchRotatedSortedArray.js)
+* [41. First Missing Positive](https://leetcode.com/problems/first-missing-positive/) -  [Solution](./Hard/41-firstMissingPositive.js)
+* [45. Jump Game II](https://leetcode.com/problems/jump-game-ii/) -  [Solution](./Hard/45-jumpGameII.js)
 * [56. Merge Intervals](https://leetcode.com/problems/merge-intervals/) -  [Solution](./Hard/56-MergeIntervals.js)
 * [57. Insert Interval](https://leetcode.com/problems/insert-interval/) -  [Solution](./Hard/57-insertInterval.js)
 * [123. Best Time to Buy and Sell Stock III](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/) -  [Solution](./Hard/123-bestTimeBuySellStockIII.js)