edit 78

Author: fishercoder1534

README.md

@@ -519,7 +519,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |81|[Search in Rotated Sorted Array II](https://leetcode.com/problems/search-in-rotated-sorted-array-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_81.java)|O(logn)|O(1)|Medium|Binary Search
 |80|[Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_80.java)|O(n) |O(n)|Medium|
 |79|[Word Search](https://leetcode.com/problems/word-search/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_79.java)|O(m*n*l) ? |O(m*n)|Medium|Backtracking, DFS
-|78|[Subsets](https://leetcode.com/problems/subsets/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_78.java)|O(n^2) ? |O(1)|Medium|Backtracking
+|78|[Subsets](https://leetcode.com/problems/subsets/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_78.java)|O(n^2) |O(1)|Medium|Backtracking
 |77|[Combinations](https://leetcode.com/problems/combinations/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_77.java)|O(n^2) ? |O(1)|Medium|Backtracking
 |76|[Minimum Window Substring](https://leetcode.com/problems/minimum-window-substring/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_76.java)|O(n)|O(k)|Hard|Two Pointers
 |75|[Sort Colors](https://leetcode.com/problems/sort-colors/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_75.java)|O(n)|O(1)|Medium| Two Pointers

src/main/java/com/fishercoder/solutions/_78.java

@@ -1,17 +1,15 @@
 package com.fishercoder.solutions;
 
-import com.fishercoder.common.utils.CommonUtils;
-
 import java.util.ArrayList;
 import java.util.List;
 
-/** Given a set of distinct integers, nums, return all possible subsets.
-
- Note: The solution set must not contain duplicate subsets.
+/**
+ * 78. Subsets
+ * Given a set of distinct integers, nums, return all possible subsets.
+ * Note: The solution set must not contain duplicate subsets.
 
  For example,
  If nums = [1,2,3], a solution is:
-
  [
  [3],
  [1],
@@ -26,46 +24,44 @@
 
 public class _78 {
 
-    public static void main(String...strings){
-//        int[] nums = new int[]{1,2,3};
-        int[] nums = new int[]{1,2,2};
-        List<List<Integer>> result = subsets_backtracking(nums);
-        CommonUtils.printListList(result);
-    }
-    
-    public static List<List<Integer>> subsets(int[] nums) {
-        List<List<Integer>> result = new ArrayList();
-        List<Integer> empty = new ArrayList();
-        result.add(empty);
-        if(nums == null) return result;
-        for(int i = 0; i < nums.length; i++){
-            List<List<Integer>> temp = new ArrayList();//you'll have to create a new one here, otherwise, it'll throw ConcurrentModificationException.
-            for(List<Integer> list : result){
-                List<Integer> newList = new ArrayList(list);
-                newList.add(nums[i]);
-                temp.add(newList);
+    public static class IterativeSolution {
+
+        public static List<List<Integer>> subsets(int[] nums) {
+            List<List<Integer>> result = new ArrayList();
+            List<Integer> empty = new ArrayList();
+            result.add(empty);
+            if (nums == null) return result;
+            for (int i = 0; i < nums.length; i++) {
+                List<List<Integer>> temp = new ArrayList();
+                //you'll have to create a new one here, otherwise, it'll throw ConcurrentModificationException.
+                for (List<Integer> list : result) {
+                    List<Integer> newList = new ArrayList(list);
+                    newList.add(nums[i]);
+                    temp.add(newList);
+                }
+                result.addAll(temp);
             }
-            result.addAll(temp);
+            return result;
         }
-        return result;
-    }
-    
-    /**this post: https://discuss.leetcode.com/topic/46159/a-general-approach-to-backtracking-questions-in-java-subsets-permutations-combination-sum-palindrome-partitioning
-     * is really cool!*/
-    public static List<List<Integer>> subsets_backtracking(int[] nums) {
-        List<List<Integer>> result = new ArrayList();
-        backtracking(result, new ArrayList(), nums, 0);
-        return result;
+
     }
 
-    private static void backtracking(List<List<Integer>> result, List<Integer> temp, int[] nums, int start) {
-        //ATTN: you'll have to make a new list here before entering the for loop
-        result.add(new ArrayList(temp));
-        for(int i = start; i < nums.length; i++){
-            if(i != start && nums[i] == nums[i-1]) continue;//add this line here to skip duplicates for _78 II
-            temp.add(nums[i]);
-            backtracking(result, temp, nums, i+1);
-            temp.remove(temp.size()-1);
+    public static class BacktrackingSolution {
+
+        public List<List<Integer>> subsets(int[] nums) {
+            List<List<Integer>> result = new ArrayList();
+            backtracking(result, new ArrayList(), nums, 0);
+            return result;
+        }
+
+        void backtracking(List<List<Integer>> result, List<Integer> temp, int[] nums, int start) {
+            result.add(new ArrayList(temp));
+            for (int i = start; i < nums.length; i++) {
+                temp.add(nums[i]);
+                backtracking(result, temp, nums, i + 1);
+                temp.remove(temp.size() - 1);
+            }
         }
+
     }
 }