**Objective: **Given a amount ‘A’ and n coins, v1<v2<v3<.….……<vn . Write a program to find out minimum numbers of coins required to make the change for the amount ‘A’.

**Exampl**e:

Amount: 5 Coins [] = 1, 2, 3. No of ways to make the change are : { 1,1,1,1,1} , {1,1,1,2}, {2,2,1},{1,1,3} and {3,2}. So as we can see minimum number of coins required are 2 ( 3+2=5}.

**Approach:**

For Every coin we have two options, whether so select it or don’t select it. So we can find out the solution with both the options and then choose the optimal one, here in this case, select the minimum among all the solutions.

First we will break the problem into smaller problems. So what are our smaller problems.

Amount is A and coins are v1, v2, .……,vn.

Say *MC(j) represents the minimum number of coins required to make change of amount j.*

Smaller Problems:

- Select 1st coin (value = v1), Now Smaller problem is minimum number of coins required to make change of amount( j-v1)
*, MC(j-v1)* - Select 2st coin (value = v2), Now Smaller problem is minimum number of coins required to make change of amount( j-v2)
*, MC(j-v2)* - Likewise to up to N
- Select nth coin (value = vn), Now Smaller problem is minimum number of coins required to make change of amount( j-v1)
*, MC(j-vn).*

We need to find the minimum number of coins required to make change for ** j** amount. So we will select the minimum of all the smaller problems and add 1 to it because we have select one coin. Now smaller problems will be solved recursively.

So if we write our recursive equation

## MC(j) = Min_{i=1 to n}[*MC(j-v*_{i})] +1

_{i})

**NOTE: **Before selecting the coin, make sure whether value of the coin is less than equal to amount needed.

**Using Recursion: **Every coin has 2 options, to be selected or not selected so

**Time Complexity: ****O(c ^{n}) **which is very high.

We can reduce the Time Complexity significantly by using Dynamic programming.

**Using Bottom-Up Dynamic Programming.**

** (Click here to read about Bottom-up Dynamic Programming)**.

- We will maintain an array to store the optimal solutions for the smaller problems, say we call it as
. length of this array will be amount+1. (starts with 0).*coinReq[]* - So
will be our final answer, minimum no of coins required to make change for amount ‘*coinReq[n]*’.*n* - Since we are using
, so will start filling the*Bottom-up approach*. we will start solving it from the smaller possible amount which is 0 here.*coinReq[] from 0 to n* - We need 0 coins to make change for amount 0, so
.*coinReq[0]=0* - We will use another array
= number of coins )will store the solution for amount n with using all the coins, minimum of all these will the optimal solution for the amount.*CC[] (size* - Since we are finding the solution for all the amounts 0 to N, we have to reset
every time ( for amount = 1 to N)*CC[]* - See the program for better explanation.

**Code:**

**Output**:

(Dynamic Programming) Minimum Coins required to make change for 20 are: 7