[Coding Made Simple] Coin Changes Minimum Number of Coins

Given coins of certain denominations and a total, how many minimum coins would you need to make this total?

 

Dynamic Programming solution 

State: T[i][j]: given the first i coins, the min number of coins needed to make a total of j.

Function:

case 1. T[i][j] = T[i - 1][j], if j < coins[i - 1], the ith coins can't be used;

case 2.  T[i][j] = Math.min(T[i - 1][j], 1 + T[i][j - coins[i - 1]]), if j >= coins[i - 1], the ith coins can be used;

Since T[i][j] is set to -1 when we can't get a total of j out of the first i coins. So in case 2, we need to check

if T[i - 1][j] or T[i][j - coins[i - 1]] is negative. If either one of them is negative, then we need to handle 

them separately. 

 

The following implementation also includes how to reconstruct one of the optimal solution.

import java.util.ArrayList;

public class CoinChange {
    private ArrayList<Integer> pickedCoins;
    public int minCoinsToGetTotal(int[] coins, int total) {
        if(total == 0) {
            return 0;
        }
        if(total != 0 && (coins == null || coins.length == 0)) {
            return -1;
        }
        int[][] T = new int[coins.length + 1][total + 1];
        for(int j = 0; j < T[0].length; j++) {
            T[0][j] = -1;
        }
        for(int i = 0; i < T.length; i++) {
            T[i][0] = 0;
        }
        for(int i = 1; i < T.length; i++) {
            for(int j = 1; j < T[0].length; j++) {
                if(j >= coins[i - 1]) {
                    if(T[i - 1][j] >= 0 && T[i][j - coins[i - 1]] >= 0) {
                        T[i][j] = Math.min(T[i - 1][j], 1 + T[i][j - coins[i - 1]]);    
                    }
                    else if(T[i - 1][j] < 0 && T[i][j - coins[i - 1]] >= 0) {
                        T[i][j] = 1 + T[i][j - coins[i - 1]];                        
                    }
                    else {
                        T[i][j] = T[i - 1][j];
                    }
                }
                else {
                    T[i][j] = T[i - 1][j];
                }
            }
        }
        int i = coins.length, j = total;
        pickedCoins = new ArrayList<Integer>();
        if(T[i][j] > 0) {
            while(T[i][j] != 0) {
                if(j >= coins[i - 1] && T[i][j - coins[i - 1]] >= 0 && 1 + T[i][j - coins[i - 1]] == T[i][j]) {
                    pickedCoins.add(coins[i - 1]);
                    j -= coins[i - 1];                                        
                }
                else{
                    i--;
                }
            }
        }
        return T[coins.length][total];
    }
}

Related Problems

Coin Changes Number of ways to get a total