078 (3) add iterative solution

stevencooks · stevencooks · commit 31da148231ab · 2015-09-30T18:38:22.000-04:00
diff --git a/src/_078_Subsets/Solution.java b/src/_078_Subsets/Solution.java
@@ -26,27 +26,44 @@
 /** see test {@link _078_Subsets.SolutionTest } */
 public class Solution {
 
+    // try to insert each number into all existing subsets
     public List<List<Integer>> subsets(int[] nums) {
-        List<List<Integer>> result = new ArrayList<List<Integer>>();
-        List<Integer> list = new ArrayList<>();
-        int pos = 0;
-        // sort because it is required to put elements in non-descending order
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
         Arrays.sort(nums);
-        subsetsHelper(nums, pos, list, result);
-        return result;
+
+        // push initial empty subset
+        res.add(new ArrayList<>());
+
+        for (int num : nums) {
+            int sz = res.size(); // we don't need temp list any more
+            for (int i = 0; i < sz; i++) {
+                List<Integer> list = new ArrayList<>(res.get(i));
+                list.add(num);
+                res.add(list);
+            }
+        }
+        return res;
     }
+    
+    // we have to use temporary list
+    public List<List<Integer>> subsets2(int[] nums) {
+        List<List<Integer>> res = new ArrayList<List<Integer>>();
+        Arrays.sort(nums);
+
+        // push initial empty subset
+        res.add(new ArrayList<>());
 
-    private void subsetsHelper(int[] nums, int pos, List<Integer> list,
-            List<List<Integer>> result) {
-        // ! not result.add(list)
-        result.add(new ArrayList<>(list));
-        for (int i = pos; i < nums.length; i++) {
-            list.add(nums[i]);
-            // ! not (pos + 1)
-            subsetsHelper(nums, i + 1, list, result);
-            list.remove(list.size() - 1);
+        for (int num : nums) {
+            // try insert num into all existing subsets
+            List<List<Integer>> temp = new ArrayList<>(); 
+            for (List<Integer> sub : res) {
+                List<Integer> list = new ArrayList<>(sub);
+                list.add(num);
+                temp.add(list);
+            }
+            res.addAll(temp);
         }
-        
+        return res;
     }
 
 }
diff --git a/src/_078_Subsets/SolutionRecursive.java b/src/_078_Subsets/SolutionRecursive.java
@@ -0,0 +1,51 @@
+/**
+ * Time : O(2^n); Space: O()
+ * @tag : Array; Backtracking; Bit Manipulation
+ * @by  : Steven Cooks
+ * @date: Jun 7, 2015
+ *************************************************************************
+ * Description: 
+ * 
+ * My Submissions Question Solution 
+ * Given a set of distinct integers, nums, return all possible subsets. 
+ * 
+ * Note: Elements in a subset must be in non-descending order. 
+ * The solution set must not contain duplicate subsets. 
+ * For example, If nums = [1,2,3], a solution is: 
+ * [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]
+ * 
+ *************************************************************************
+ * {@link https://leetcode.com/problems/subsets/ }
+ */
+package _078_Subsets;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/** see test {@link _078_Subsets.SolutionTest } */
+public class SolutionRecursive {
+
+    public List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> result = new ArrayList<List<Integer>>();
+        List<Integer> list = new ArrayList<>();
+        int pos = 0;
+        // sort because it is required to put elements in non-descending order
+        Arrays.sort(nums);
+        subsetsHelper(nums, pos, list, result);
+        return result;
+    }
+
+    private void subsetsHelper(int[] nums, int pos, List<Integer> list,
+            List<List<Integer>> result) {
+        // ! not result.add(list)
+        result.add(new ArrayList<>(list));
+        for (int i = pos; i < nums.length; i++) {
+            list.add(nums[i]);
+            // ! not (pos + 1)
+            subsetsHelper(nums, i + 1, list, result);
+            list.remove(list.size() - 1);
+        }
+    }
+
+}
diff --git a/test/_078_Subsets/SolutionRecursiveTest.java b/test/_078_Subsets/SolutionRecursiveTest.java
@@ -0,0 +1,96 @@
+package _078_Subsets;
+
+import static com.leetcode.Test.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.Timeout;
+
+public class SolutionRecursiveTest {
+
+    /** Test method for {@link _078_Subsets.SolutionRecursive } */
+    SolutionRecursive solution;
+    
+    @Rule
+    public Timeout globalTimeout = new Timeout(500);
+
+    @Before
+    public void setUp() throws Exception {
+        solution = new SolutionRecursive();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        solution = null;
+    }
+
+    @Test
+    public void Test1() {
+        int[] nums = { 1, 2, 3 };
+        List<List<Integer>> actuals = solution.subsets(nums);
+        List<List<Integer>> expecteds = new ArrayList<>();
+        expecteds.add(Arrays.asList());
+        expecteds.add(Arrays.asList(1));
+        expecteds.add(Arrays.asList(2));
+        expecteds.add(Arrays.asList(3));
+        expecteds.add(Arrays.asList(1, 3));
+        expecteds.add(Arrays.asList(1, 2));
+        expecteds.add(Arrays.asList(2, 3));
+        expecteds.add(Arrays.asList(1, 2, 3));
+        assertEqualsIgnoreOrder(expecteds, actuals);
+    }
+
+    @Test
+    public void Test2() {
+        int[] nums = { 1, 2 };
+        List<List<Integer>> actual = solution.subsets(nums);
+        List<List<Integer>> expecteds = new ArrayList<>();
+        expecteds.add(Arrays.asList());
+        expecteds.add(Arrays.asList(1));
+        expecteds.add(Arrays.asList(2));
+        expecteds.add(Arrays.asList(1, 2));
+        assertEqualsIgnoreOrder(expecteds, actual);
+    }
+
+    @Test
+    public void Test3() {
+        int[] nums = { 1 };
+        List<List<Integer>> actual = solution.subsets(nums);
+        List<List<Integer>> expecteds = new ArrayList<>();
+        expecteds.add(Arrays.asList());
+        expecteds.add(Arrays.asList(1));
+        assertEqualsIgnoreOrder(expecteds, actual);
+    }
+
+    @Test
+    public void Test4() {
+        int[] nums = { 4, 1, 0 };
+        List<List<Integer>> actual = solution.subsets(nums);
+        List<List<Integer>> expecteds = new ArrayList<>();
+        expecteds.add(Arrays.asList());
+        expecteds.add(Arrays.asList(0));
+        expecteds.add(Arrays.asList(0, 1));
+        expecteds.add(Arrays.asList(0, 4));
+        expecteds.add(Arrays.asList(0, 1, 4));
+        expecteds.add(Arrays.asList(1));
+        expecteds.add(Arrays.asList(1, 4));
+        expecteds.add(Arrays.asList(4));
+        assertEqualsIgnoreOrder(expecteds, actual);
+    }
+
+    @Test
+    public void Test5() {
+        int[] nums = { };
+        List<List<Integer>> actual = solution.subsets(nums);
+        List<List<Integer>> expecteds = new ArrayList<>();
+        expecteds.add(Arrays.asList());
+        assertEqualsIgnoreOrder(expecteds, actual);
+    }
+
+}
