README + next permutation + subset

Author: Cappuccinuo

Array/31. Next Permutation/README.md

@@ -0,0 +1,20 @@
+Time spent : 10 min(self)
+
+GIVEN: an array
+
+RETURNS: rearrange numbers into the lexicographically next greater permutation of numbers
+
+If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).
+
+EXAMPLES:
+
+`1,2,3` → `1,3,2`
+`3,2,1` → `1,2,3`
+`1,1,5` → `1,5,1`
+
+[Algorithm][https://leetcode.com/problems/global-and-local-inversions/solution/]:
+
+1. Traverse the array from right to left, find the first index i, that num[i] > nums[i - 1] or i == 0.
+2. When i is not 0, use j to traverse from right to left again, find the first index j that nums[j] > nums[i - 1], then exchange nums[j] and nums[i - 1].
+3. Reverse the nums from i to the end of array.
+

Array/31. Next Permutation/Solution.java

@@ -0,0 +1,37 @@
+// 2018.4.8 
+class Solution {
+    public void nextPermutation(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return;
+        }
+        int n = nums.length;
+        if (n == 1) {
+            return;
+        }
+        
+        int i = n - 1;
+        while (i > 0 && nums[i] <= nums[i - 1]) {
+            i--;
+        }
+        if (i != 0) {
+            int j = n - 1;
+            while (nums[j] <= nums[i - 1]) {
+                j--;
+            }
+            swap(nums, i - 1, j);
+        }
+        swapList(nums, i, n - 1);
+    }
+    
+    public void swapList(int[] nums, int start, int end) {
+        while (start < end) {
+            swap(nums, start++, end--);
+        }
+    }
+    
+    public void swap(int[] nums, int i, int j) {
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+}

DFS/78. Subsets/README.md renamed to Backtracking/78. Subsets/README.md

@@ -0,0 +1,82 @@
+// 2018.4.7 DFS
+class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> result = new LinkedList<>();
+        if (nums == null) {
+            return result;
+        }
+        Arrays.sort(nums);
+        dfs(nums, 0, new LinkedList<>(), result);
+        return result;
+    }
+    
+    // 1. Definition of DFS
+    private void dfs(int[] nums, 
+                     int index, 
+                     List<Integer> subset, 
+                     List<List<Integer>> result) {
+        // 3. Exit of DFS
+        if (index == nums.length) {
+            result.add(new LinkedList<Integer>(subset));
+            return;
+        }
+        
+        // 2. Recursion Division
+        // Pick
+        subset.add(nums[index]);
+        dfs(nums, index + 1, subset, result);
+        
+        // Not pick
+        subset.remove(subset.size() - 1);
+        dfs(nums, index + 1, subset, result);
+    }
+}
+
+// 2018.4.7 Genreral DFS
+class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> result = new LinkedList<>();
+        if (nums == null) {
+            return result;
+        }
+        dfs(nums, 0, new LinkedList<Integer>(), result);
+        return result;
+    }
+    
+    private void dfs(int[] nums, 
+                     int startIndex, 
+                     List<Integer> subset, 
+                     List<List<Integer>> result) {
+        result.add(new LinkedList<Integer>(subset));
+        
+        for (int i = startIndex; i < nums.length; i++) {
+            subset.add(nums[i]);
+            dfs(nums, i + 1, subset, result);
+            subset.remove(subset.size() - 1);
+        }
+    }
+}
+
+class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> result = new LinkedList<>();
+        if (nums == null) {
+            return result;
+        }
+        dfs(nums, 0, new LinkedList<Integer>(), result);
+        return result;
+    }
+    
+    private void dfs(int[] nums, 
+                     int startIndex, 
+                     List<Integer> subset, 
+                     List<List<Integer>> result) {
+        result.add(subset);
+        
+        for (int i = startIndex; i < nums.length; i++) {
+            List<Integer> newSet = new LinkedList<>(subset);
+            newSet.add(nums[i]);
+            dfs(nums, i + 1, newSet, result);
+        }
+    }
+}