C++ coin change program

In this article, we will see the most asked interview problem. The coin change problem is a good example of a dynamic programming approach. Now let us understand the problem statement.

Problem statement

Given N and an array(say coins[]) that contains some numbers(coins in rupees). N is a coin, and the array contains various coins. The task is to make the change of N using the coins of the array. Make a change in such a way that a minimum number of coins are used.

Example

Let us take a input array coins[] = {10, 25, 5}, total coins = 3

We have N = 30.

The output is two as we can use one 25 rupee coin and a 5 rupee coin to make 30. (25 + 5 = 30)

Similarly, coins[] = {1, 9, 6, 5}, total coins = 4

N = 13

The output is three as we need two 6 rupees coins and one 1 rupee coin. (6 + 6 + 1 = 13)

Approach 1

The approach uses a recursive method. We start with N, and in each iteration, we divide the problem into smaller subproblems. This is done by taking every coin from the coins array and decrease it from N. The case where N comes to zero gives us the required solution. For an optimal answer, we return the minimum of all combinations.

C++ code

#include <bits/stdc++.h>
using namespace std;


int minCoins(int coins[], int total_coins, int N) // Function to return the minimum // coins needed 
{
        if (N == 0) // If we have a combination then 
        return 0;

    int result = INT_MAX; // Currently result is initialised as INT_MAX 

    for (int i = 0; i < total_coins; i++) // run until availability of coins
    {
        if (coins[i] <= N) { // Add to the list of counting 
            int sub_res = 1 + minCoins(coins, total_coins, N - coins[i]); // add 1 due to the coin inclusion
            // see if result can minimize
            if (sub_res < result)
                result = sub_res;
        }
    }
    return result;
}

int main()
{
    int coins[] = { 10, 25, 5 };
    int sum = 30; // the money to convert
    int total_coins = 3; // total availability of coins
    cout << "Minmum coins needed are " << minCoins(coins, total_coins, sum);
}

Output

Minimum coins needed are 2

The above solution does not work for more significant inputs. In this case, the recursive approach fails.

Now let us look at an optimized approach.

Approach 2

This approach uses the idea of bottom-up dynamic programming.

Since subproblems are computed, again and again, there is a condition of overlapping subproblems. The problem of recomputation can be solved using the property of memoization, i.e., create a dp[] array that stores the computed values at a particular stage. At each stage calculate all the possible combinations. After all the combinations, the last value in the dp[] array gives us the answer.

C++ code

#include <bits/stdc++.h>
using namespace std;

int coins[] = { 10, 25, 5 }; // coins array
int dp[1000] = { 0 }; // array for memoisation
int minCoins(int N, int M) // N is the sum , M is total_coins
{

    for (int i = 0; i <= N; i++)
        dp[i] = INT_MAX; // Initialise all dp[] value to INT_MAX

    dp[0] = 0; // Base case if sum becomes zero min rupees = 0

    //Iterating in the outer loop for possible values of sum between 1 to N
    //Since our final solution for sum = N might depend upon any of these values
    for (int i = 1; i <= N; i++) {
        //Inner loop denotes the index of coin array.
        //For each value of sum, to obtain the optimal solution.
        for (int j = 0; j < M; j++) {
            //i ?> sum
            //j ?> next coin index
            //If we can include this coin in our solution
            if (coins[j] <= i) {
                //Solution might include the newly included coin
                dp[i] = min(dp[i], 1 + dp[i - coins[j]]);
            }
        }
    }
    return dp[N];
}

int main()
{

    int sum = 30; // the money to convert
    int total_coins = 3; // total availability of coins
    cout << "Minimum coins needed are " << minCoins(sum, total_coins);
}

Output

Minimum coins needed are 2

The time complexity of the code is O(total_coins + sum). This is a much-optimized approach because of storing the results at each stage and utilizing it on the other iterations.

Next TopicC++ program to add two complex numbers using class

← prev next →