refactor 416

fishercoder1534 · fishercoder1534 · commit 25b68c883558 · 2019-03-17T08:05:21.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_416.java b/src/main/java/com/fishercoder/solutions/_416.java
@@ -31,46 +31,49 @@
  Explanation: The array cannot be partitioned into equal sum subsets.
  */
 public class _416 {
+    public static class Solution1 {
+        /**
+         * credit: https://discuss.leetcode.com/topic/67539/0-1-knapsack-detailed-explanation
+         */
+        public boolean canPartition(int[] nums) {
+            int sum = 0;
+            for (int num : nums) {
+                sum += num;
+            }
 
-    /**credit: https://discuss.leetcode.com/topic/67539/0-1-knapsack-detailed-explanation*/
-    public boolean canPartition(int[] nums) {
-        int sum = 0;
-        for (int num : nums) {
-            sum += num;
-        }
-
-        if ((sum & 1) == 1) {
-            return false;
-        }
+            if ((sum & 1) == 1) {
+                return false;
+            }
 
-        sum /= 2;
+            sum /= 2;
 
-        int n = nums.length;
-        boolean[][] dp = new boolean[n + 1][sum + 1];
-        for (int i = 0; i < dp.length; i++) {
-            Arrays.fill(dp[i], false);
-        }
+            int n = nums.length;
+            boolean[][] dp = new boolean[n + 1][sum + 1];
+            for (int i = 0; i < dp.length; i++) {
+                Arrays.fill(dp[i], false);
+            }
 
-        dp[0][0] = true;
+            dp[0][0] = true;
 
-        for (int i = 1; i < n + 1; i++) {
-            dp[i][0] = true;
-        }
-
-        for (int j = 1; j < sum + 1; j++) {
-            dp[0][j] = false;
-        }
+            for (int i = 1; i < n + 1; i++) {
+                dp[i][0] = true;
+            }
 
-        for (int i = 1; i < n + 1; i++) {
             for (int j = 1; j < sum + 1; j++) {
-                dp[i][j] = dp[i - 1][j];
-                if (j >= nums[i - 1]) {
-                    dp[i][j] = (dp[i][j] || dp[i - 1][j - nums[i - 1]]);
+                dp[0][j] = false;
+            }
+
+            for (int i = 1; i < n + 1; i++) {
+                for (int j = 1; j < sum + 1; j++) {
+                    dp[i][j] = dp[i - 1][j];
+                    if (j >= nums[i - 1]) {
+                        dp[i][j] = (dp[i][j] || dp[i - 1][j - nums[i - 1]]);
+                    }
                 }
             }
-        }
 
-        return dp[n][sum];
+            return dp[n][sum];
+        }
     }
 
 }
diff --git a/src/test/java/com/fishercoder/_416Test.java b/src/test/java/com/fishercoder/_416Test.java
@@ -6,34 +6,31 @@
 
 import static org.junit.Assert.assertEquals;
 
-/**
- * Created by stevesun on 6/5/17.
- */
 public class _416Test {
-    private static _416 test;
+    private static _416.Solution1 solution1;
     private static int[] nums;
 
     @BeforeClass
     public static void setup() {
-        test = new _416();
+        solution1 = new _416.Solution1();
     }
 
     @Test
     public void test1() {
         nums = new int[]{1, 5, 11, 5};
-        assertEquals(true, test.canPartition(nums));
+        assertEquals(true, solution1.canPartition(nums));
     }
 
     @Test
     public void test2() {
         nums = new int[]{1, 2, 3, 5};
-        assertEquals(false, test.canPartition(nums));
+        assertEquals(false, solution1.canPartition(nums));
     }
 
     @Test
     public void test3() {
         nums = new int[]{1, 2, 3, 4, 5, 6, 7};
-        assertEquals(true, test.canPartition(nums));
+        assertEquals(true, solution1.canPartition(nums));
     }
 
 }
