refactor 656

Author: fishercoder1534

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

@@ -1,6 +1,5 @@
 package com.fishercoder.solutions;
 
-
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -35,38 +34,40 @@
  */
 
 public class _656 {
+    public static class Solution1 {
 
-    /**
-     * Time: O(n*B)
-     * Reference: https://leetcode.com/articles/coin-path/#approach-3-using-dynamic-programming-accepted
-     */
-    public List<Integer> cheapestJump(int[] A, int B) {
-        int[] next = new int[A.length];
-        long[] dp = new long[A.length];
-        Arrays.fill(next, -1);
-        List<Integer> res = new ArrayList();
-        for (int i = A.length - 2; i >= 0; i--) {
-            long minCost = Integer.MAX_VALUE;
-            for (int j = i + 1; j <= i + B && j < A.length; j++) {
-                if (A[j] >= 0) {
-                    long cost = A[i] + dp[j];
-                    if (cost < minCost) {
-                        minCost = cost;
-                        next[i] = j;
+        /**
+         * Time: O(n*B)
+         * Reference: https://leetcode.com/articles/coin-path/#approach-3-using-dynamic-programming-accepted
+         */
+        public List<Integer> cheapestJump(int[] A, int B) {
+            int[] next = new int[A.length];
+            long[] dp = new long[A.length];
+            Arrays.fill(next, -1);
+            List<Integer> res = new ArrayList();
+            for (int i = A.length - 2; i >= 0; i--) {
+                long minCost = Integer.MAX_VALUE;
+                for (int j = i + 1; j <= i + B && j < A.length; j++) {
+                    if (A[j] >= 0) {
+                        long cost = A[i] + dp[j];
+                        if (cost < minCost) {
+                            minCost = cost;
+                            next[i] = j;
+                        }
                     }
                 }
+                dp[i] = minCost;
             }
-            dp[i] = minCost;
-        }
-        int i;
-        for (i = 0; i < A.length && next[i] > 0; i = next[i]) {
-            res.add(i + 1);
-        }
-        if (i == A.length - 1 && A[i] >= 0) {
-            res.add(A.length);
-        } else {
-            return new ArrayList<>();
+            int i;
+            for (i = 0; i < A.length && next[i] > 0; i = next[i]) {
+                res.add(i + 1);
+            }
+            if (i == A.length - 1 && A[i] >= 0) {
+                res.add(A.length);
+            } else {
+                return new ArrayList<>();
+            }
+            return res;
         }
-        return res;
     }
 }

src/test/java/com/fishercoder/_656Test.java

@@ -14,19 +14,19 @@
  * Created by fishercoder on 5/25/17.
  */
 public class _656Test {
-    private static _656 test;
+    private static _656.Solution1 solution1;
     private static int[] A;
     private static List<Integer> expected;
 
     @BeforeClass
     public static void setup() {
-        test = new _656();
+        solution1 = new _656.Solution1();
     }
 
     @Test
     public void test1() {
         A = new int[]{1, 2, 4, -1, 2};
         expected = new ArrayList<>(Arrays.asList(1, 3, 5));
-        assertEquals(expected, test.cheapestJump(A, 2));
+        assertEquals(expected, solution1.cheapestJump(A, 2));
     }
 }