add 656

Author: fishercoder1534

README.md

@@ -26,6 +26,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |659|[Split Array into Consecutive Subsequences](https://leetcode.com/problems/split-array-into-consecutive-subsequences/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_659.java) | O(n) | O(n) | Medium | HashMap
 |658|[Find K Closest Elements](https://leetcode.com/problems/find-k-closest-elements/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_658.java) | O(n) | O(1) | Medium |
 |657|[Judge Route Circle](https://leetcode.com/problems/judge-route-circle/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_657.java) | O(n) | O(1) | Easy | 
+|656|[Coin Path](https://leetcode.com/problems/coin-path/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_656.java) | O(n*B) | O(n) | Hard | DP
 |654|[Maximum Binary Tree](https://leetcode.com/problems/maximum-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_654.java) | O(n^2) | O(n) | Medium | Tree
 |653|[Two Sum IV - Input is a BST](https://leetcode.com/problems/two-sum-iv-input-is-a-bst/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_653.java) |  |  | Easy | Tree
 |652|[Find Duplicate Subtrees](https://leetcode.com/problems/find-duplicate-subtrees/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_652.java) | O(n) |O(n) | Medium | Tree

pom.xml

@@ -7,8 +7,10 @@
     <groupId>com.fishercoder</groupId>
     <artifactId>leetcode-algorithms</artifactId>
     <version>1.0-SNAPSHOT</version>
+
     <build>
         <plugins>
+
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
@@ -17,6 +19,26 @@
                     <target>1.8</target>
                 </configuration>
             </plugin>
+
+            <!--<plugin>-->
+                <!--<groupId>org.apache.maven.plugins</groupId>-->
+                <!--<artifactId>maven-checkstyle-plugin</artifactId>-->
+                <!--<version>2.9.1</version>-->
+                <!--<executions>-->
+                    <!--<execution>-->
+                        <!--<id>checkstyle</id>-->
+                        <!--<phase>validate</phase>-->
+                        <!--<goals>-->
+                            <!--<goal>check</goal>-->
+                        <!--</goals>-->
+                        <!--<configuration>-->
+                            <!--<configLocation>fishercoder_codestyle.xml</configLocation>-->
+                            <!--&lt;!&ndash;<failOnViolation>true</failOnViolation>&ndash;&gt;-->
+                        <!--</configuration>-->
+                    <!--</execution>-->
+                <!--</executions>-->
+            <!--</plugin>-->
+
         </plugins>
     </build>
 
@@ -34,14 +56,12 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-checkstyle-plugin</artifactId>
-                <version>2.17</version>
-                <reportSets>
-                    <reportSet>
-                        <reports>
-                            <report>checkstyle</report>
-                        </reports>
-                    </reportSet>
-                </reportSets>
+                <version>2.9.1</version>
+                <configuration>
+                    <failOnViolation>true</failOnViolation>
+                    <includeTestSourceDirectory>true</includeTestSourceDirectory>
+                    <configLocation>${project.basedir}/fishercoder_codestyle.xml</configLocation>
+                </configuration>
             </plugin>
         </plugins>
     </reporting>

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

@@ -0,0 +1,69 @@
+package com.fishercoder.solutions;
+
+import java.util.*;
+
+/**
+ * 656. Coin Path
+ *
+ * Given an array A (index starts at 1) consisting of N integers: A1, A2, ..., AN and an integer B.
+ * The integer B denotes that from any place (suppose the index is i) in the array A,
+ * you can jump to any one of the place in the array A indexed i+1, i+2, …, i+B if this place can be jumped to.
+ * Also, if you step on the index i, you have to pay Ai coins. If Ai is -1, it means you can’t jump to the place indexed i in the array.
+ * Now, you start from the place indexed 1 in the array A,
+ * and your aim is to reach the place indexed N using the minimum coins.
+ * You need to return the path of indexes (starting from 1 to N) in the array you should take to get to the place indexed N using minimum coins.
+ * If there are multiple paths with the same cost, return the lexicographically smallest such path.
+ * If it's not possible to reach the place indexed N then you need to return an empty array.
+
+ Example 1:
+ Input: [1,2,4,-1,2], 2
+ Output: [1,3,5]
+
+ Example 2:
+ Input: [1,2,4,-1,2], 1
+ Output: []
+
+ Note:
+ Path Pa1, Pa2, ..., Pan is lexicographically smaller than Pb1, Pb2, ..., Pbm,
+ if and only if at the first i where Pai and Pbi differ, Pai < Pbi; when no such i exists, then n < m.
+ A1 >= 0. A2, ..., AN (if exist) will in the range of [-1, 100].
+ Length of A is in the range of [1, 1000].
+ B is in the range of [1, 100].
+ */
+
+public class _656 {
+
+    /**
+     * 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 min_cost = 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 < min_cost) {
+                        min_cost = cost;
+                        next[i] = j;
+                    }
+                }
+            }
+            dp[i] = min_cost;
+        }
+        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;
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._656;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Created by fishercoder on 5/25/17.
+ */
+public class _656Test {
+    private static _656 test;
+    private static int[] A;
+    private static List<Integer> expected;
+
+    @BeforeClass
+    public static void setup(){
+        test = new _656();
+    }
+
+    @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));
+    }
+}