refactor 377

Author: fishercoder1534

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

@@ -2,7 +2,9 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * 377. Combination Sum IV
@@ -67,6 +69,7 @@ public static class Solution2 {
          * However, it also ended up in TLE by this testcase: [1,2,3], 32
          */
         public static int count = 0;
+
         public int combinationSum4(int[] nums, int target) {
             Arrays.sort(nums);
             backtracking(nums, target, new ArrayList());
@@ -88,6 +91,9 @@ private void backtracking(int[] nums, int target, List<Integer> list) {
 
     public static class Solution3 {
         /**
+         * Time: O(n^2)
+         * Space: O(n)
+         *
          * Since this question doesn't require to return all the combination result, instead, it just wants one number, we could use DP
          * the idea is similar to Climbing Stairs.
          *
@@ -116,4 +122,32 @@ public int combinationSum4(int[] nums, int target) {
             return result[target];
         }
     }
+
+    public static class Solution4 {
+        /**
+         * Time: O(n)
+         * Space: O(n)
+         *
+         * Reference: https://discuss.leetcode.com/topic/52255/java-recursion-solution-using-hashmap-as-memory
+         */
+        public static Map<Integer, Integer> map = new HashMap<>();//need to remove public static before submitting on Leetcode as it doesn't reset static variables
+
+        public int combinationSum4(int[] nums, int target) {
+            if (nums == null || nums.length == 0 || target < 0) {
+                return 0;
+            }
+            if (target == 0) {
+                return 1;
+            }
+            if (map.containsKey(target)) {
+                return map.get(target);
+            }
+            int count = 0;
+            for (int num : nums) {
+                count += combinationSum4(nums, target - num);
+            }
+            map.put(target, count);
+            return count;
+        }
+    }
 }

src/test/java/com/fishercoder/_377Test.java

@@ -1,6 +1,7 @@
 package com.fishercoder;
 
 import com.fishercoder.solutions._377;
+import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
@@ -10,6 +11,7 @@ public class _377Test {
     private static _377.Solution1 solution1;
     private static _377.Solution2 solution2;
     private static _377.Solution3 solution3;
+    private static _377.Solution4 solution4;
     private static int[] nums;
     private static int target;
 
@@ -18,6 +20,14 @@ public static void setup() {
         solution1 = new _377.Solution1();
         solution2 = new _377.Solution2();
         solution3 = new _377.Solution3();
+        solution4 = new _377.Solution4();
+    }
+
+    @Before
+    public void setUp() throws Exception {
+        //always have to reset these global variables before using it again
+        solution2.count = 0;
+        solution4.map.clear();
     }
 
     @Test
@@ -27,6 +37,7 @@ public void test1() {
         assertEquals(7, solution1.combinationSum4(nums, target));
         assertEquals(7, solution2.combinationSum4(nums, target));
         assertEquals(7, solution3.combinationSum4(nums, target));
+        assertEquals(7, solution4.combinationSum4(nums, target));
     }
 
     @Test
@@ -35,10 +46,21 @@ public void test2() {
         target = 32;
 //        assertEquals(39882198, solution1.combinationSum4(nums, target));//this results in MLE, so comment out
 
-        solution2.count = 0;//always have to reset this global variable to be zero before using it again
         assertEquals(39882198, solution2.combinationSum4(nums, target));
 
         assertEquals(39882198, solution3.combinationSum4(nums, target));
+
+        assertEquals(39882198, solution4.combinationSum4(nums, target));
+    }
+
+    @Test
+    public void test3() {
+        nums = new int[]{9};
+        target = 3;
+        assertEquals(0, solution1.combinationSum4(nums, target));
+        assertEquals(0, solution2.combinationSum4(nums, target));
+        assertEquals(0, solution3.combinationSum4(nums, target));
+        assertEquals(0, solution4.combinationSum4(nums, target));
     }
 
 }