update more solutions

Author: FreeTymeKiyan

src/main/java/com/freetymekiyan/algorithms/level/hard/FirstMissingPositive.java

@@ -2,39 +2,44 @@
 
 /**
  * Given an unsorted integer array, find the first missing positive integer.
- * 
+ * <p>
  * For example,
  * Given [1,2,0] return 3,
  * and [3,4,-1,1] return 2.
- * 
+ * <p>
  * Your algorithm should run in O(n) time and uses constant space.
- * 
+ * <p>
  * Tags: Array
  */
 class FirstMissingPositive {
-    public static void main(String[] args) {
-        int[] A = {1,2,0};
-        System.out.println(new FirstMissingPositive().firstMissingPositive(A));
+  public static void main(String[] args) {
+    int[] A = {1, 2, 0};
+    System.out.println(new FirstMissingPositive().firstMissingPositive(A));
+  }
+
+  /**
+   * Position of integer n should be n - 1 if sorted
+   * Correct form [1, 2, 3, 4, ..., #, n]
+   * If not in position swap it with nums[nums[p]-1]
+   */
+  public int firstMissingPositive(int[] nums) {
+    if (nums == null || nums.length == 0) {
+      return 1;
+    }
+    int length = nums.length;
+    for (int i = 0; i < length; i++) {
+      int num = nums[i];
+      while (nums[i] <= length && nums[i] > 0 && nums[num - 1] != num) {
+        nums[i] = nums[num - 1];
+        nums[num - 1] = num;
+        num = nums[i];
+      }
     }
-    
-    /**
-     * Position of integer n should be n - 1 if sorted
-     * Correct form [1, 2, 3, 4, ..., #, n]
-     * If not in position swap it with A[A[p]-1]
-     */
-    public static int firstMissingPositive(int[] A) {
-        if (A == null || A.length == 0) return 1;
-        int n = A.length;
-        for (int i = 0; i < n; i++) {
-            int num = A[i];
-            while (A[i] <= n && A[i] > 0 && A[num - 1] != num) {
-                A[i] = A[num - 1];
-                A[num - 1] = num;
-                num = A[i];
-            }
-        }
-        for (int i = 0; i < n; i++) 
-            if (A[i] != i + 1) return i + 1;
-        return n + 1; // nothing in middle losing, return largest
+    for (int i = 0; i < length; i++) {
+      if (nums[i] != i + 1) {
+        return i + 1;
+      }
     }
+    return length + 1; // Nothing in middle missing, return largest
+  }
 }

src/main/java/com/freetymekiyan/algorithms/level/hard/JumpGame2.java

@@ -3,45 +3,42 @@
 /**
  * Given an array of non-negative integers, you are initially positioned at the
  * first index of the array.
- * 
+ * <p>
  * Each element in the array represents your maximum jump length at that
  * position.
- * 
+ * <p>
  * Your goal is to reach the last index in the minimum number of jumps.
- * 
+ * <p>
  * For example:
  * Given array A = [2,3,1,1,4]
- * 
+ * <p>
  * The minimum number of jumps to reach the last index is 2. (Jump 1 step from
  * index 0 to 1, then 3 steps to the last index.)
- * 
+ * <p>
  * Tags: Array, Greedy, DP
  */
 class JumpGame2 {
-    public static void main(String[] args) {
-        
-    }
-    
-    /**
-     * Use last to store how far we already can reach
-     * Compare i with last
-     * If we run out of it, update and add 1 more step to result
-     * Return if last is already bigger than or equal to the length
-     * Use cur to store how far we can reach for the next step
-     */
-    public int jump(int[] A) {
-        int step = 0;
-        int last = 0; // how far we already can reach
-        int cur = 0; // how far can we reach for next step
-        
-        for (int i = 0; i < A.length; i++) {
-            if (i > last) { // run out of we can reach, need one more step
-                last = cur;
-                step++;
-                if (last >= A.length) return step;
-            }
-            cur = Math.max(cur, i + A[i]);
-        }
-        return step;
+
+  /**
+   * Use last to store how far we already can reach
+   * Compare i with last
+   * If we run out of it, update and add 1 more step to result
+   * Return if last is already bigger than or equal to the length
+   * Use cur to store how far we can reach for the next step
+   */
+  public int jump(int[] A) {
+    int step = 0;
+    int last = 0; // How far we already can reach
+    int cur = 0; // How far can we reach for next step
+
+    for (int i = 0; i < A.length; i++) {
+      if (i > last) { // Run out of we can reach, need one more step
+        last = cur;
+        step++;
+        if (last >= A.length) return step;
+      }
+      cur = Math.max(cur, i + A[i]);
     }
+    return step;
+  }
 }

src/main/java/com/freetymekiyan/algorithms/level/hard/Permutations2.java

@@ -1,116 +1,121 @@
 package com.freetymekiyan.algorithms.level.hard;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * Given a collection of numbers that might contain duplicates, return all
  * possible unique permutations.
- * 
+ * <p>
  * For example,
  * [1,1,2] have the following unique permutations:
  * [1,1,2], [1,2,1], and [2,1,1].
- * 
+ * <p>
  * Tags: Backtracking
  */
 class Permutations2 {
-    public static void main(String[] args) {
-        List<List<Integer>> res = permuteUniqueB(new int[]{1, 2, 3});
-        for (List<Integer> l : res) System.out.println(l);
-    }
-    
-    /**
-     * Same idea as Permutation 1 except we skip if duplicate of current element
-     * is found in previous sequence
-     */
-    public List<List<Integer>> permuteUnique(int[] num) {
-        List<List<Integer>> res = new ArrayList<List<Integer>>();
-        if (num == null || num.length == 0) return res;
-        Arrays.sort(num);
-        permute(num, 0, res);
-        return res;
+
+  /**
+   * Lexicography Order next permutation
+   * Find the next permutation in lexicographic order.
+   * http://en.wikipedia.org/wiki/Permutation#Generation_in_lexicographic_order
+   */
+  public List<List<Integer>> permuteUniqueB(int[] num) {
+    List<List<Integer>> res = new ArrayList<>();
+    if (num == null || num.length == 0) return res;
+    Arrays.sort(num);
+    List<Integer> row = new ArrayList<>();
+    for (int a : num) row.add(a);
+    res.add(new ArrayList<>(row)); // first permutation
+    while (nextPermutation(row)) { // if there is next permutation
+      res.add(new ArrayList<>(row));
     }
-    
-    public void permute(int[] num, int pos, List<List<Integer>> res) {
-        if (pos == num.length) {
-            List<Integer> row = new ArrayList<Integer>();
-            for (int a : num) row.add(a);
-            res.add(row);
-            return;
-        }
-        for (int i = pos; i < num.length; i++) {
-            // skip if we have duplicates of current element before i
-            boolean skip = false;
-            for (int j = pos; j < i; j++) {
-                if (num[j] == num[i]) {
-                    skip = true;
-                    break;
-                }
-            }
-            if (skip) continue;
-            swap(num, pos, i);
-            permute(num, pos + 1, res);
-            swap(num, pos, i); // reset
-        }
+    return res;
+  }
+
+  /**
+   * e.g.: 1234 -> 1243, 1243 -> 1324
+   * Traverse backward to get 3
+   * Then traverse forward to get furthest number bigger than 3
+   * Swap these two digits and reverse from next to last
+   */
+  private boolean nextPermutation(List<Integer> row) {
+    int last = row.size() - 1;
+    for (int pos = last - 1; pos >= 0; pos--) {
+      if (row.get(pos) < row.get(pos + 1)) {
+        int smallIdx = pos;
+        int biggerIdx = pos + 1;
+        for (int i = pos + 1; i <= last; i++)
+          if (row.get(i) > row.get(pos)) biggerIdx = i;
+        swap(row, smallIdx, biggerIdx);
+        reverse(row, pos + 1, last);
+        return true;
+      }
     }
+    return false;
+  }
+
+  private void swap(List<Integer> row, int a, int b) {
+    int t = row.get(a);
+    row.set(a, row.get(b));
+    row.set(b, t);
+  }
 
-    public void swap(int[] num, int i, int j) {
-        if (i == j) return;
-        num[i] = num[j] - num[i];
-        num[j] = num[j] - num[i];
-        num[i] = num[j] + num[i];
+  private void reverse(List<Integer> row, int s, int e) {
+    while (s < e) {
+      swap(row, s, e);
+      s++;
+      e--;
     }
-    
-    /**
-     * Lexicography Order next permutation
-     * Find the next permutation in lexicographic order.
-     *http://en.wikipedia.org/wiki/Permutation#Generation_in_lexicographic_order
-     */
-    public static List<List<Integer>> permuteUniqueB(int[] num) {
-        List<List<Integer>> res = new ArrayList<List<Integer>>();
-        if (num == null || num.length == 0) return res;
-        Arrays.sort(num);
-        List<Integer> row = new ArrayList<Integer>();
-        for (int a : num) row.add(a);
-        res.add(new ArrayList<Integer>(row)); // first permutation
-        while (nextPermutation(row)) { // if there is next permutation
-            res.add(new ArrayList<Integer>(row));
-        }
-        return res;
-    } 
-    
-    /**
-     * e.g.: 1234 -> 1243, 1243 -> 1324
-     * Traverse backward to get 3
-     * Then traverse forward to get furthest number bigger than 3
-     * Swap these two digits and reverse from next to last
-     */
-    public static boolean nextPermutation(List<Integer> row) {
-        int last = row.size() - 1;
-        for (int pos = last - 1; pos >= 0; pos--) {
-            if (row.get(pos) < row.get(pos + 1)) {
-                int smallIdx = pos;
-                int biggerIdx = pos + 1;
-                for (int i = pos + 1; i <= last; i++) 
-                    if (row.get(i) > row.get(pos)) biggerIdx = i;
-                swap(row, smallIdx, biggerIdx);
-                reverse(row, pos + 1, last);
-                return true;
-            }
-        }
-        return false;
+  }
+
+  /**
+   * Same idea as Permutation 1 except we skip if duplicate of current element
+   * is found in previous sequence
+   */
+  public List<List<Integer>> permuteUnique(int[] num) {
+    if (num == null || num.length == 0) {
+      return Collections.emptyList();
     }
-    
-    public static void swap(List<Integer> row, int a, int b) {
-        int t = row.get(a);
-        row.set(a, row.get(b));
-        row.set(b, t);
+    Arrays.sort(num);
+    final List<List<Integer>> res = new ArrayList<>();
+    dfs(num, 0, res);
+    return res;
+  }
+
+  private void dfs(int[] num, int pos, List<List<Integer>> res) {
+    if (pos == num.length) {
+      final List<Integer> row = new ArrayList<>(num.length);
+      for (int a : num) {
+        row.add(a);
+      }
+      res.add(row);
+      return;
     }
-    
-    public static void reverse(List<Integer> row, int s, int e) {
-        while (s < e) {
-            swap(row, s, e);
-            s++;
-            e--;
+    for (int i = pos; i < num.length; i++) {
+      // Skip if we have duplicates of current element before i
+      boolean skip = false;
+      for (int j = pos; j < i; j++) {
+        if (num[j] == num[i]) {
+          skip = true;
+          break;
         }
+      }
+      if (skip) continue;
+      swap(num, pos, i);
+      dfs(num, pos + 1, res);
+      swap(num, pos, i); // Reset
+    }
+  }
+
+  private void swap(int[] num, int i, int j) {
+    if (i == j) {
+      return;
     }
+    num[i] = num[j] - num[i];
+    num[j] = num[j] - num[i];
+    num[i] = num[j] + num[i];
+  }
 }