Coin change

Author: William Fiset

slides/dynamicprogramming/coin_change.key

@@ -15,27 +15,22 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 
 public class CoinChange {
 
   public static class Solution {
-    int minCoins;
+    // Contains the minimum number of coins to make a certain amount, if an optimal solution exists.
+    Optional<Integer> minCoins = Optional.empty();
+
+    // The coins selected as part of the optimal solution.
     List<Integer> selectedCoins = new ArrayList<Integer>();
   }
 
   // TODO(william): setting an explicit infinity could lead to a wrong answer for
   // very large values. Prefer to use null instead.
   private static final int INF = Integer.MAX_VALUE / 2;
 
-  private static void p(int[][] dp) {
-    for (int[] r : dp) {
-      for (int v : r) {
-        System.out.printf("%4d, ", v == INF ? -1 : v);
-      }
-      System.out.println();
-    }
-  }
-
   public static Solution coinChange(int[] coins, final int n) {
     if (coins == null) throw new IllegalArgumentException("Coins array is null");
     if (coins.length == 0) throw new IllegalArgumentException("No coin values :/");
@@ -70,11 +65,10 @@ public static Solution coinChange(int[] coins, final int n) {
 
     Solution solution = new Solution();
 
-    // The amount we wanted to make cannot be made :/
-    if (dp[m][n] == INF) {
-      solution.minCoins = -1;
+    if (dp[m][n] != INF) {
+      solution.minCoins = Optional.of(dp[m][n]);
     } else {
-      solution.minCoins = dp[m][n];
+      return solution;
     }
 
     for (int change = n, coinIndex = m; coinIndex > 0; ) {
@@ -91,7 +85,7 @@ public static Solution coinChange(int[] coins, final int n) {
     return solution;
   }
 
-  public static int coinChangeSpaceEfficient(int[] coins, int n) {
+  public static Solution coinChangeSpaceEfficient(int[] coins, int n) {
     if (coins == null) throw new IllegalArgumentException("Coins array is null");
 
     // Initialize table and set everything to infinity except first cell
@@ -107,11 +101,31 @@ public static int coinChangeSpaceEfficient(int[] coins, int n) {
       }
     }
 
-    // The amount we wanted to make cannot be made :/
-    if (dp[n] == INF) return -1;
+    Solution solution = new Solution();
+    if (dp[n] != INF) {
+      solution.minCoins = Optional.of(dp[n]);
+    } else {
+      return solution;
+    }
+
+    for (int i = n; i > 0; ) {
+      int selectedCoinValue = INF;
+      int cellWithFewestCoins = dp[i];
+      for (int coin : coins) {
+        if (i - coin < 0) {
+          continue;
+        }
+        if (dp[i - coin] < cellWithFewestCoins) {
+          cellWithFewestCoins = dp[i - coin];
+          selectedCoinValue = coin;
+        }
+      }
+      solution.selectedCoins.add(selectedCoinValue);
+      i -= selectedCoinValue;
+    }
 
     // Return the minimum number of coins needed
-    return dp[n];
+    return solution;
   }
 
   // The recursive approach has the advantage that it does not have to visit
@@ -142,6 +156,23 @@ private static int coinChangeRecursive(int n, int[] coins, int[] dp) {
     return dp[n] = (minCoins == INF) ? -1 : minCoins;
   }
 
+  // DP table print function. Used for debugging.
+  private static void p(int[][] dp) {
+    for (int[] r : dp) {
+      for (int v : r) {
+        System.out.printf("%4d, ", v == INF ? -1 : v);
+      }
+      System.out.println();
+    }
+  }
+
+  private static void p(int[] dp) {
+    for (int v : dp) {
+      System.out.printf("%4d, ", v == INF ? -1 : v);
+    }
+    System.out.println();
+  }
+
   public static void main(String[] args) {
     // example1();
     // example2();
@@ -152,10 +183,10 @@ public static void main(String[] args) {
   private static void example4() {
     int n = 11;
     int[] coins = {2, 4, 1};
-    System.out.println(coinChange(coins, n).minCoins);
+    // System.out.println(coinChange(coins, n).minCoins);
     System.out.println(coinChangeSpaceEfficient(coins, n));
-    System.out.println(coinChangeRecursive(coins, n));
-    System.out.println(coinChange(coins, n).selectedCoins);
+    // System.out.println(coinChangeRecursive(coins, n));
+    // System.out.println(coinChange(coins, n).selectedCoins);
   }
 
   private static void example1() {

src/main/java/com/williamfiset/algorithms/dp/CoinChange.java

@@ -20,8 +20,9 @@ public void testCoinChange() {
       int amount = TestUtils.randValue(1, 1000);
 
       CoinChange.Solution solution1 = CoinChange.coinChange(coinValues, amount);
-      int v1 = solution1.minCoins;
-      int v2 = CoinChange.coinChangeSpaceEfficient(coinValues, amount);
+      CoinChange.Solution solution2 = CoinChange.coinChangeSpaceEfficient(coinValues, amount);
+      int v1 = solution1.minCoins.isPresent() ? solution1.minCoins.get() : -1;
+      int v2 = solution2.minCoins.isPresent() ? solution2.minCoins.get() : -1;
       int v3 = CoinChange.coinChangeRecursive(coinValues, amount);
 
       assertThat(v1).isEqualTo(v2);
@@ -42,11 +43,36 @@ public void testCoinChangeSelectedCoins() {
       for (int v : solution.selectedCoins) {
         selectedCoinsSum += v;
       }
-      if (solution.minCoins == -1) {
+      if (!solution.minCoins.isPresent()) {
         assertThat(solution.selectedCoins.size()).isEqualTo(0);
       } else {
         // Verify that the size of the selected coins is equal to the optimal solution.
-        assertThat(solution.selectedCoins.size()).isEqualTo(solution.minCoins);
+        assertThat(solution.selectedCoins.size()).isEqualTo(solution.minCoins.get());
+
+        // Further verify that the sum of the selected coins equals the amount we want to make.
+        assertThat(selectedCoinsSum).isEqualTo(amount);
+      }
+    }
+  }
+
+  @Test
+  public void testCoinChangeSpaceEfficientSelectedCoins() {
+    for (int i = 1; i < LOOPS; i++) {
+      List<Integer> values = TestUtils.randomIntegerList(i, 1, 1000);
+      int[] coinValues = Ints.toArray(values);
+
+      int amount = TestUtils.randValue(1, 1000);
+
+      CoinChange.Solution solution = CoinChange.coinChangeSpaceEfficient(coinValues, amount);
+      int selectedCoinsSum = 0;
+      for (int v : solution.selectedCoins) {
+        selectedCoinsSum += v;
+      }
+      if (!solution.minCoins.isPresent()) {
+        assertThat(solution.selectedCoins.size()).isEqualTo(0);
+      } else {
+        // Verify that the size of the selected coins is equal to the optimal solution.
+        assertThat(solution.selectedCoins.size()).isEqualTo(solution.minCoins.get());
 
         // Further verify that the sum of the selected coins equals the amount we want to make.
         assertThat(selectedCoinsSum).isEqualTo(amount);