Merge branch 'master' of github.com:OneCodeMonkey/DailyAlgo

� Conflicts:
�	leetcode_solved/leetcode_0047_Permutations_II.java

Author: OneCodeMonkey

leetcode_solved/[editing]leetcode_0047_Permutations_II.cpp

@@ -1,5 +1,33 @@
+// AC: Runtime: 83 ms, faster than 9.78% of Java online submissions for Permutations II.
+// Memory Usage: 40.1 MB, less than 24.22% of Java online submissions for Permutations II.
+// backtracking
+// T:O(2^n), S:O(n * 2^n)
+// 
 class Solution {
     public List<List<Integer>> permuteUnique(int[] nums) {
-        
+        HashSet<List<Integer>> record = new HashSet<>();
+        int[] used = new int[nums.length];
+        backtracking(nums, used, new LinkedList<>(), record);
+
+        return new LinkedList<>(record);
+    }
+
+    private void backtracking(int[] nums, int[] used, List<Integer> path, HashSet<List<Integer>> out) {
+        List<Integer> pathCopy = new LinkedList<>(path);
+        if (pathCopy.size() >= nums.length) {
+            out.add(pathCopy);
+            return;
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            if (used[i] == 1) {
+                continue;
+            }
+            pathCopy.add(nums[i]);
+            used[i] = 1;
+            backtracking(nums, used, pathCopy, out);
+            pathCopy.remove(pathCopy.size() - 1);
+            used[i] = 0;
+        }
     }
 }

leetcode_solved/[editing]leetcode_0060_Permutation_Sequence.cpp

@@ -0,0 +1,63 @@
+// AC: Runtime: 1 ms, faster than 98.32% of Java online submissions for Permutation Sequence.
+// Memory Usage: 36 MB, less than 99.03% of Java online submissions for Permutation Sequence.
+// get the forwarding bit of every position, then construct the string by the bit-list
+// T:O(n^2), S:O(n)
+// 
+class Solution {
+    public String getPermutation(int n, int k) {
+        k--;
+        // get the forwarding bit of every position on the base of [1,2,3,4,5,...]
+        List<Integer> bit = new LinkedList<>();
+        for (int i = n - 1; i >= 1; i--) {
+            int factorI = getFactor(i);
+            if (k >= factorI) {
+                int temp = k / factorI;
+                bit.add(temp);
+                k = k % factorI;
+            } else {
+                bit.add(0);
+            }
+        }
+        bit.add(0);
+
+        // forwarding by every bit
+        int[] used = new int[n + 1];
+        StringBuilder ret = new StringBuilder();
+        for (int i = 0; i < n; i++) {
+            if (bit.get(i) != 0) {
+                int count = 0;
+                for (int j = 1; j < used.length; j++) {
+                    if (used[j] == 0) {
+                        if (count < bit.get(i)) {
+                            count++;
+                        } else {
+                            ret.append(j);
+                            used[j] = 1;
+                            break;
+                        }
+                    }
+                }
+            } else {
+                for (int j = 1; j < used.length; j++) {
+                    if (used[j] == 0) {
+                        ret.append(j);
+                        used[j] = 1;
+                        break;
+                    }
+                }
+            }
+        }
+
+        return ret.toString();
+    }
+
+    private int getFactor(int n) {
+        int ret = 1;
+        while (n > 1) {
+            ret *= n;
+            n--;
+        }
+
+        return ret;
+    }
+}

leetcode_solved/[editing]leetcode_0078_Subsets.cpp

@@ -0,0 +1,28 @@
+// AC: Runtime: 6 ms, faster than 11.49% of Java online submissions for Subsets II.
+// Memory Usage: 39.3 MB, less than 46.18% of Java online submissions for Subsets II.
+// backtracking
+// T:O(2^n), S:O(n * 2^n)
+//
+class Solution {
+    public List<List<Integer>> subsetsWithDup(int[] nums) {
+        HashSet<List<Integer>> record = new HashSet<>();
+        record.add(new LinkedList<>());
+//        int[] used = new int[nums.length];
+        backtracking(nums, new LinkedList<>(), record, 0);
+
+        return new LinkedList<>(record);
+    }
+
+    private void backtracking(int[] nums, List<Integer> path, HashSet<List<Integer>> out, int startIndex) {
+        List<Integer> pathCopy = new LinkedList<>(path);
+        // combination does not varify by order, so first sort to remove dup.
+        Collections.sort(pathCopy);
+        out.add(pathCopy);
+
+        for (int i = startIndex; i < nums.length; i++) {
+            pathCopy.add(nums[i]);
+            backtracking(nums, pathCopy, out, i + 1);
+            pathCopy.remove(pathCopy.size() - 1);
+        }
+    }
+}

leetcode_solved/[editing]leetcode_0090_Subsets_II.cpp

@@ -0,0 +1,51 @@
+// Solution 1: binary search of every row(or column)
+// AC: Runtime: 5 ms, faster than 49.82% of Java online submissions for Search a 2D Matrix II.
+// Memory Usage: 45 MB, less than 23.65% of Java online submissions for Search a 2D Matrix II.
+// binary search, but not use the row and column both ordered condition, so there are better solution
+// T:O(row * log(col)), S:O(log(col))
+//
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int row = matrix.length, col = matrix[0].length;
+
+        for (int[] ints : matrix) {
+            if (Arrays.binarySearch(ints, target) >= 0) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+
+// Solution 2: search from top-right, move left or down to search
+// AC: Runtime: 4 ms, faster than 100.00% of Java online submissions for Search a 2D Matrix II.
+// Memory Usage: 44.5 MB, less than 78.90% of Java online submissions for Search a 2D Matrix II.
+// two-direction move, see the annotation
+// T:O(row + col), S:O(1)
+//
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int row = matrix.length, col = matrix[0].length;
+        int rowPos = 0, colPos = col - 1;
+        while (matrix[rowPos][colPos] != target) {
+            // left move for one column
+            if (matrix[rowPos][colPos] > target) {
+                colPos--;
+                if (colPos < 0) {
+                    return false;
+                }
+            } 
+            // down move for one row
+            else {
+                rowPos++;
+                if (rowPos >= row) {
+                    return false;
+                }
+            }
+        }
+
+        // cannot remove, check the final position is target or not.
+        return matrix[rowPos][colPos] == target;
+    }
+}