# Find minimum number of coins to make a given value (Coin Change)

Last Updated : 20 Oct, 2023

Given an array coins[] of size N and a target value V, where coins[i] represents the coins of different denominations. You have an infinite supply of each of coins. The task is to find minimum number of coins required to make the given value V. If it’s not possible to make a change, print -1.

Examples:

Input: coins[] = {25, 10, 5}, V = 30
Output: Minimum 2 coins required We can use one coin of 25 cents and one of 5 cents

Input: coins[] = {9, 6, 5, 1}, V = 11
Output: Minimum 2 coins required We can use one coin of 6 cents and 1 coin of 5 cents

Recommended Practice

## Find minimum number of coins to make a given value using Recursion

This problem is a variation of the problem discussed Coin Change Problem. Here instead of finding the total number of possible solutions, we need to find the solution with the minimum number of coins.

The minimum number of coins for a value V can be computed using the below recursive formula.

• If V == 0:
• 0 coins required
• If V > 0:
• minCoins(coins[0..m-1], V ) = min { 1 + minCoins(V-coin[i])} where, 0 <=i <= m-1 and coins[i] <= V.

Below is a implementation of the above approach:

## C++

 `// A Naive recursive C++ program to find minimum of coins` `// to make a given change V` `#include` `using` `namespace` `std;`   `// m is size of coins array (number of different coins)` `int` `minCoins(``int` `coins[], ``int` `m, ``int` `V)` `{` `   ``// base case` `   ``if` `(V == 0) ``return` `0;`   `   ``// Initialize result` `   ``int` `res = INT_MAX;`   `   ``// Try every coin that has smaller value than V` `   ``for` `(``int` `i=0; i

## Java

 `// A Naive recursive JAVA program to find minimum of coins` `// to make a given change V` `import` `java.io.*;` `public` `class` `coin` `{` `    ``// m is size of coins array (number of different coins)` `    ``static` `int` `minCoins(``int` `coins[], ``int` `m, ``int` `V)` `    ``{` `       ``// base case` `       ``if` `(V == ``0``) ``return` `0``;` `     `  `       ``// Initialize result` `       ``int` `res = Integer.MAX_VALUE;` `     `  `       ``// Try every coin that has smaller value than V` `       ``for` `(``int` `i=``0``; i

## Python3

 `# A Naive recursive python program to find minimum of coins` `# to make a given change V`   `import` `sys`   `# m is size of coins array (number of different coins)` `def` `minCoins(coins, m, V):`   `    ``# base case` `    ``if` `(V ``=``=` `0``):` `        ``return` `0`   `    ``# Initialize result` `    ``res ``=` `sys.maxsize` `    `  `    ``# Try every coin that has smaller value than V` `    ``for` `i ``in` `range``(``0``, m):` `        ``if` `(coins[i] <``=` `V):` `            ``sub_res ``=` `minCoins(coins, m, V``-``coins[i])`   `            ``# Check for INT_MAX to avoid overflow and see if` `            ``# result can minimized` `            ``if` `(sub_res !``=` `sys.maxsize ``and` `sub_res ``+` `1` `< res):` `                ``res ``=` `sub_res ``+` `1`   `    ``return` `res`   `# Driver program to test above function` `coins ``=` `[``9``, ``6``, ``5``, ``1``]` `m ``=` `len``(coins)` `V ``=` `11` `print``(``"Minimum coins required is"``,minCoins(coins, m, V))`   `# This code is contributed by` `# Smitha Dinesh Semwal`

## C#

 `// A Naive recursive C# program` `// to find minimum of coins` `// to make a given change V` `using` `System;` `class` `coin` `{` `    `  `    ``// m is size of coins array ` `    ``// (number of different coins)` `    ``static` `int` `minCoins(``int` `[]coins, ``int` `m, ``int` `V)` `    ``{` `        `  `        ``// base case` `        ``if` `(V == 0) ``return` `0;` `        `  `        ``// Initialize result` `        ``int` `res = ``int``.MaxValue;` `        `  `        ``// Try every coin that has` `        ``// smaller value than V` `        ``for` `(``int` `i = 0; i < m; i++)` `        ``{` `            ``if` `(coins[i] <= V)` `            ``{` `                ``int` `sub_res = minCoins(coins, m,` `                                  ``V - coins[i]);` `        `  `                ``// Check for INT_MAX to ` `                ``// avoid overflow and see ` `                ``// if result can minimized` `                ``if` `(sub_res != ``int``.MaxValue && ` `                            ``sub_res + 1 < res)` `                    ``res = sub_res + 1;` `            ``}` `        ``}` `        ``return` `res;` `    ``}` `    `  `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `[]coins = {9, 6, 5, 1};` `        ``int` `m = coins.Length;` `        ``int` `V = 11;` `        ``Console.Write(``"Minimum coins required is "``+` `                             ``minCoins(coins, m, V));` `    ``}` `}`   `// This code is contributed by nitin mittal.`

## Javascript

 ``

## PHP

 ``

Output

`Minimum coins required is 2`

Time Complexity: O(m^V)
Auxiliary Space: O(V)

## Find minimum number of coins to make a given value using Dynamic Programming (Top Down/Memoization)

The idea is to find the Number of ways of Denominations By using the Top Down (Memoization).

Algorithm:

• Creating a 2-D vector to store the Overlapping Solutions
• Keep Track of the overlapping subproblems while Traversing the array coins[]
• Recall them whenever needed.

Below is the implementation using the Top Down Memoized Approach

## C++

 `#include ` `using` `namespace` `std;`   `// Utility function for solving the minimum coins problem` `int` `minCoinsUtil(``int` `coins[], ``int` `m, ``int` `V, ``int``* dp)` `{` `    ``// Base case: If target value V is 0, no coins are` `    ``// needed` `    ``if` `(V == 0)` `        ``return` `0;`   `    ``// If subproblem is already solved, return the result` `    ``// from DP table` `    ``if` `(dp[V] != -1)` `        ``return` `dp[V];`   `    ``int` `res = INT_MAX;`   `    ``// Iterate over all coins and recursively solve for` `    ``// subproblems` `    ``for` `(``int` `i = 0; i < m; i++) {` `        ``if` `(coins[i] <= V) {` `            ``// Recursive call to solve for remaining value V` `            ``// - coins[i]` `            ``int` `sub_res` `                ``= minCoinsUtil(coins, m, V - coins[i], dp);`   `            ``// If the subproblem has a valid solution and` `            ``// the total number of coins is smaller than the` `            ``// current result, update the result` `            ``if` `(sub_res != INT_MAX && sub_res + 1 < res)` `                ``res = sub_res + 1;` `        ``}` `    ``}`   `    ``// Save the result in the DP table` `    ``dp[V] = res;`   `    ``return` `res;` `}`   `// Function to find the minimum number of coins needed to` `// make a target value` `int` `minCoins(``int` `coins[], ``int` `m, ``int` `V)` `{` `    ``// Create a DP table to store results of subproblems` `    ``int``* dp = ``new` `int``[V + 1];` `    ``memset``(dp, -1,` `           ``sizeof``(``int``)` `               ``* (V + 1)); ``// Initialize DP table with -1`   `    ``// Call the utility function to solve the problem` `    ``return` `minCoinsUtil(coins, m, V, dp);` `}`   `// Driver code` `int` `main()` `{` `    ``int` `coins[] = { 9, 6, 5, 1 };` `    ``int` `m = ``sizeof``(coins) / ``sizeof``(coins[0]);` `    ``int` `V = 11;`   `    ``int` `res = minCoins(coins, m, V);` `    ``if` `(res == INT_MAX)` `        ``res = -1;`   `    ``// Find the minimum number of coins required` `    ``cout << ``"Minimum coins required is "` `<< res;`   `    ``return` `0;` `}`

## Java

 `import` `java.util.Arrays;`   `public` `class` `MinimumCoins {` `    ``// Utility function for solving the minimum coins` `    ``// problem` `    ``public` `static` `int` `minCoinsUtil(``int``[] coins, ``int` `m,` `                                   ``int` `V, ``int``[] dp)` `    ``{` `        ``// Base case: If target value V is 0, no coins are` `        ``// needed` `        ``if` `(V == ``0``)` `            ``return` `0``;`   `        ``// If subproblem is already solved, return the` `        ``// result from DP table` `        ``if` `(dp[V] != -``1``)` `            ``return` `dp[V];`   `        ``int` `res = Integer.MAX_VALUE;`   `        ``// Iterate over all coins and recursively solve for` `        ``// subproblems` `        ``for` `(``int` `i = ``0``; i < m; i++) {` `            ``if` `(coins[i] <= V) {` `                ``// Recursive call to solve for remaining` `                ``// value V - coins[i]` `                ``int` `sub_res = minCoinsUtil(` `                    ``coins, m, V - coins[i], dp);`   `                ``// If the subproblem has a valid solution` `                ``// and the total number of coins is smaller` `                ``// than the current result, update the` `                ``// result` `                ``if` `(sub_res != Integer.MAX_VALUE` `                    ``&& sub_res + ``1` `< res)` `                    ``res = sub_res + ``1``;` `            ``}` `        ``}`   `        ``// Save the result in the DP table` `        ``dp[V] = res;`   `        ``return` `res;` `    ``}`   `    ``// Function to find the minimum number of coins needed` `    ``// to make a target value` `    ``public` `static` `int` `minCoins(``int``[] coins, ``int` `m, ``int` `V)` `    ``{` `        ``// Create a DP table to store results of subproblems` `        ``int``[] dp = ``new` `int``[V + ``1``];` `        ``Arrays.fill(dp, -``1``); ``// Initialize DP table with -1`   `        ``// Call the utility function to solve the problem` `        ``return` `minCoinsUtil(coins, m, V, dp);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] coins = { ``9``, ``6``, ``5``, ``1` `};` `        ``int` `m = coins.length;` `        ``int` `V = ``11``;`   `        ``int` `res = minCoins(coins, m, V);` `        ``if` `(res == Integer.MAX_VALUE)` `            ``res = -``1``;`   `        ``// Find the minimum number of coins required` `        ``System.out.println(``"Minimum coins required is "` `                           ``+ res);` `    ``}` `}`

## Python3

 `import` `sys`   `# Utility function for solving the minimum coins problem`     `def` `minCoinsUtil(coins, m, V, dp):` `    ``# Base case: If target value V is 0, no coins are needed` `    ``if` `V ``=``=` `0``:` `        ``return` `0`   `    ``# If subproblem is already solved, return the result from DP table` `    ``if` `dp[V] !``=` `-``1``:` `        ``return` `dp[V]`   `    ``res ``=` `sys.maxsize`   `    ``# Iterate over all coins and recursively solve for subproblems` `    ``for` `i ``in` `range``(m):` `        ``if` `coins[i] <``=` `V:` `            ``# Recursive call to solve for remaining value V - coins[i]` `            ``sub_res ``=` `minCoinsUtil(coins, m, V ``-` `coins[i], dp)`   `            ``# If the subproblem has a valid solution and the total number of coins` `            ``# is smaller than the current result, update the result` `            ``if` `sub_res !``=` `sys.maxsize ``and` `sub_res ``+` `1` `< res:` `                ``res ``=` `sub_res ``+` `1`   `    ``# Save the result in the DP table` `    ``dp[V] ``=` `res`   `    ``return` `res`   `# Function to find the minimum number of coins needed to make a target value`     `def` `minCoins(coins, m, V):` `    ``# Create a DP table to store results of subproblems` `    ``dp ``=` `[``-``1``] ``*` `(V ``+` `1``)`   `    ``# Call the utility function to solve the problem` `    ``return` `minCoinsUtil(coins, m, V, dp)`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``coins ``=` `[``9``, ``6``, ``5``, ``1``]` `    ``m ``=` `len``(coins)` `    ``V ``=` `11` `    ``res ``=` `minCoins(coins, m, V)`   `    ``if` `res ``=``=` `sys.maxsize:` `        ``res ``=` `-``1`   `    ``# Find the minimum number of coins required` `    ``print``(``"Minimum coins required is"``, res)`

## C#

 `using` `System;`   `    ``class` `MinimumCoinChange` `    ``{` `        ``static` `int` `minCoinsUtil(``int``[] coins, ``int` `m, ``int` `V, ``int``[] dp)` `        ``{` `            ``// Base case: If target value V is 0, no coins are` `            ``// needed` `            ``if` `(V == 0)` `                ``return` `0;`   `            ``// If subproblem is already solved, return the result` `            ``// from DP table` `            ``if` `(dp[V] != -1)` `                ``return` `dp[V];`   `            ``int` `res = ``int``.MaxValue;`   `            ``// Iterate over all coins and recursively solve for` `            ``// subproblems` `            ``for` `(``int` `i = 0; i < m; i++)` `            ``{` `                ``if` `(coins[i] <= V)` `                ``{` `                    ``// Recursive call to solve for remaining value V` `                    ``// - coins[i]` `                    ``int` `sub_res = minCoinsUtil(coins, m, V - coins[i], dp);`   `                    ``// If the subproblem has a valid solution and` `                    ``// the total number of coins is smaller than the` `                    ``// current result, update the result` `                    ``if` `(sub_res != ``int``.MaxValue && sub_res + 1 < res)` `                        ``res = sub_res + 1;` `                ``}` `            ``}`   `            ``// Save the result in the DP table` `            ``dp[V] = res;`   `            ``return` `res;` `        ``}`   `        ``static` `int` `minCoins(``int``[] coins, ``int` `m, ``int` `V)` `        ``{` `            ``// Create a DP table to store results of subproblems` `            ``int``[] dp = ``new` `int``[V + 1];` `            ``Array.Fill(dp, -1); ``// Initialize DP table with -1`   `            ``// Call the utility function to solve the problem` `            ``return` `minCoinsUtil(coins, m, V, dp);` `        ``}`   `        ``static` `void` `Main(``string``[] args)` `        ``{` `            ``int``[] coins = { 9, 6, 5, 1 };` `            ``int` `m = coins.Length;` `            ``int` `V = 11;`   `            ``int` `res = minCoins(coins, m, V);` `            ``if` `(res == ``int``.MaxValue)` `                ``res = -1;`   `            ``// Find the minimum number of coins required` `            ``Console.WriteLine(``"Minimum coins required is "` `+ res);`   `            ``Console.ReadLine();` `        ``}` `}`

## Javascript

 `function` `minCoinsUtil(coins, m, V, dp) {` `    ``if` `(V === 0) {` `        ``return` `0;` `    ``}`   `    ``if` `(dp[V] !== -1) {` `        ``return` `dp[V];` `    ``}`   `    ``let res = Infinity;`   `    ``for` `(let i = 0; i < m; i++) {` `        ``if` `(coins[i] <= V) {` `            ``let sub_res = minCoinsUtil(coins, m, V - coins[i], dp);`   `            ``if` `(sub_res !== Infinity && sub_res + 1 < res) {` `                ``res = sub_res + 1;` `            ``}` `        ``}` `    ``}`   `    ``dp[V] = res;`   `    ``return` `res;` `}`   `function` `minCoins(coins, m, V) {` `    ``const dp = ``new` `Array(V + 1).fill(-1);`   `    ``return` `minCoinsUtil(coins, m, V, dp);` `}`   `const coins = [9, 6, 5, 1];` `const m = coins.length;` `const V = 11;`     `const res = minCoins(coins, m,V);` `if``(res == Infinity) res = -1;`   `console.log(``"Minimum coins required is"``, res);`

Output

`Minimum coins required is 2`

Time Complexity: O(m * V)
Auxiliary Space: (V)

## Find minimum number of coins that make a given value using Dynamic Programming (Tabulation/ Bottom Up):

Since the same subproblems are called again, this problem has both properties Overlapping Subproblems and Optimal Substructure. Like other typical Dynamic Programming(DP) problems, recomputations of the same subproblems can be avoided by constructing a temporary array table[][] in a bottom-up manner.

Below is a implementation of the above approach:

## C++

 `// A Dynamic Programming based C++ program to find minimum` `// of coins to make a given change V` `#include ` `using` `namespace` `std;`   `// m is size of coins array (number of different coins)` `int` `minCoins(``int` `coins[], ``int` `m, ``int` `V)` `{` `    ``// table[i] will be storing the minimum number of coins` `    ``// required for i value.  So table[V] will have result` `    ``int` `table[V + 1];`   `    ``// Base case (If given value V is 0)` `    ``table[0] = 0;`   `    ``// Initialize all table values as Infinite` `    ``for` `(``int` `i = 1; i <= V; i++)` `        ``table[i] = INT_MAX;`   `    ``// Compute minimum coins required for all` `    ``// values from 1 to V` `    ``for` `(``int` `i = 1; i <= V; i++) {` `        ``// Go through all coins smaller than i` `        ``for` `(``int` `j = 0; j < m; j++)` `            ``if` `(coins[j] <= i) {` `                ``int` `sub_res = table[i - coins[j]];` `                ``if` `(sub_res != INT_MAX` `                    ``&& sub_res + 1 < table[i])` `                    ``table[i] = sub_res + 1;` `            ``}` `    ``}`   `    ``if` `(table[V] == INT_MAX)` `        ``return` `-1;`   `    ``return` `table[V];` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``int` `coins[] = { 9, 6, 5, 1 };` `    ``int` `m = ``sizeof``(coins) / ``sizeof``(coins[0]);` `    ``int` `V = 11;` `    ``cout << ``"Minimum coins required is "` `         ``<< minCoins(coins, m, V);` `    ``return` `0;` `}`

## Java

 `// A Dynamic Programming based Java` `// program to find minimum of coins` `// to make a given change V` `import` `java.io.*;`   `class` `GFG ` `{` `    ``// m is size of coins array ` `    ``// (number of different coins)` `    ``static` `int` `minCoins(``int` `coins[], ``int` `m, ``int` `V)` `    ``{` `        ``// table[i] will be storing ` `        ``// the minimum number of coins` `        ``// required for i value. So ` `        ``// table[V] will have result` `        ``int` `table[] = ``new` `int``[V + ``1``];`   `        ``// Base case (If given value V is 0)` `        ``table[``0``] = ``0``;`   `        ``// Initialize all table values as Infinite` `        ``for` `(``int` `i = ``1``; i <= V; i++)` `        ``table[i] = Integer.MAX_VALUE;`   `        ``// Compute minimum coins required for all` `        ``// values from 1 to V` `        ``for` `(``int` `i = ``1``; i <= V; i++)` `        ``{` `            ``// Go through all coins smaller than i` `            ``for` `(``int` `j = ``0``; j < m; j++)` `            ``if` `(coins[j] <= i)` `            ``{` `                ``int` `sub_res = table[i - coins[j]];` `                ``if` `(sub_res != Integer.MAX_VALUE ` `                       ``&& sub_res + ``1` `< table[i])` `                       ``table[i] = sub_res + ``1``;` `                       `  `                `  `            ``}` `            `  `        ``}` `      `  `          ``if``(table[V]==Integer.MAX_VALUE)` `            ``return` `-``1``;` `      `  `        ``return` `table[V];` `        `  `    ``}`   `    ``// Driver program ` `    ``public` `static` `void` `main (String[] args) ` `    ``{` `        ``int` `coins[] = {``9``, ``6``, ``5``, ``1``};` `        ``int` `m = coins.length;` `        ``int` `V = ``11``;` `        ``System.out.println ( ``"Minimum coins required is "` `                            ``+ minCoins(coins, m, V));` `    ``}` `}`   `//This Code is contributed by vt_m.`

## Python3

 `# A Dynamic Programming based Python3 program to ` `# find minimum of coins to make a given change V` `import` `sys `   `# m is size of coins array (number of ` `# different coins)` `def` `minCoins(coins, m, V):` `    `  `    ``# table[i] will be storing the minimum ` `    ``# number of coins required for i value. ` `    ``# So table[V] will have result` `    ``table ``=` `[``0` `for` `i ``in` `range``(V ``+` `1``)]`   `    ``# Base case (If given value V is 0)` `    ``table[``0``] ``=` `0`   `    ``# Initialize all table values as Infinite` `    ``for` `i ``in` `range``(``1``, V ``+` `1``):` `        ``table[i] ``=` `sys.maxsize`   `    ``# Compute minimum coins required ` `    ``# for all values from 1 to V` `    ``for` `i ``in` `range``(``1``, V ``+` `1``):` `        `  `        ``# Go through all coins smaller than i` `        ``for` `j ``in` `range``(m):` `            ``if` `(coins[j] <``=` `i):` `                ``sub_res ``=` `table[i ``-` `coins[j]]` `                ``if` `(sub_res !``=` `sys.maxsize ``and` `                    ``sub_res ``+` `1` `< table[i]):` `                    ``table[i] ``=` `sub_res ``+` `1` `    `  `    ``if` `table[V] ``=``=` `sys.maxsize:` `        ``return` `-``1` `      `  `    ``return` `table[V]`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``coins ``=` `[``9``, ``6``, ``5``, ``1``]` `    ``m ``=` `len``(coins)` `    ``V ``=` `11` `    ``print``(``"Minimum coins required is "``, ` `                 ``minCoins(coins, m, V))`   `# This code is contributed by ita_c`

## C#

 `// A Dynamic Programming based ` `// Java program to find minimum ` `// of coins to make a given ` `// change V` `using` `System;`   `class` `GFG` `{`   `// m is size of coins array ` `// (number of different coins)` `static` `int` `minCoins(``int` `[]coins,` `                    ``int` `m, ``int` `V)` `{` `    ``// table[i] will be storing ` `    ``// the minimum number of coins` `    ``// required for i value. So ` `    ``// table[V] will have result` `    ``int` `[]table = ``new` `int``[V + 1];`   `    ``// Base case (If given` `    ``// value V is 0)` `    ``table[0] = 0;`   `    ``// Initialize all table` `    ``// values as Infinite` `    ``for` `(``int` `i = 1; i <= V; i++)` `    ``table[i] = ``int``.MaxValue;` `    `  `    ``// Compute minimum coins ` `    ``// required for all` `    ``// values from 1 to V` `    ``for` `(``int` `i = 1; i <= V; i++)` `    ``{` `        ``// Go through all coins` `        ``// smaller than i` `        ``for` `(``int` `j = 0; j < m; j++)` `        ``if` `(coins[j] <= i)` `        ``{` `            ``int` `sub_res = table[i - coins[j]];` `            ``if` `(sub_res != ``int``.MaxValue && ` `                ``sub_res + 1 < table[i])` `                ``table[i] = sub_res + 1;` `        ``}` `    ``}` ` `  `    ``return` `table[V];` `    `  `}`   `// Driver Code ` `static` `public` `void` `Main ()` `{` `    ``int` `[]coins = {9, 6, 5, 1};` `    ``int` `m = coins.Length;` `    ``int` `V = 11;` `    ``Console.WriteLine(``"Minimum coins required is "` `+ ` `                             ``minCoins(coins, m, V));` `}` `}`   `// This code is contributed ` `// by akt_mit`

## Javascript

 ``

## PHP

 ``

Output

`Minimum coins required is 2`

Time Complexity: O(m*V).
Auxiliary Space: O(V) because using extra space for array table

Previous Article
Next Article
Article Tags :