How can i program a recursive coin change in c++?

Question

I'm trying to build a recursive call for coin change in c++ . i tried most of the algorithm on the internet but it doesn't seem to apply with vector or it doesn't out the sums of the coin used. Can anyone help me understand what the recursive function has to call? So my algorithm doesn't give me the minimum number of coin used and i don't know how to save the coin used.

int coin(vector<int> denom, int s,int N)
{
    if(N == 0)
    {
        return 1;
    }
    if(N < 0 || (N > 0 && s < 0))
    {
        return 0;
    }

    return min(coin(denom,s - 1, N), 1 + coin(denom, s,N-denom[s-1]));

}


 Input a value N:
    Input: 40
 Input how many denominations:
    Input: 3
 Denominations #1: 
    Input: 5
 Denominations #2:
    Input: 20
 Denominations #3:
    Input: 30

 Output:
 Minimum # of coins: 2
 Coin used: 20 + 20
 Don't want:  30 + 5 + 5

Answer 1

Some points to consider:

• Firstly, there is no need to send the number of denominations i.e. s as an argument to the coin method as long as a vector is being used, because vector has inbuilt size() method which does that job for us.
• Secondly, to save the solution you need another vector of int named solution, but this vector is just to keep a record and has nothing to do with the actual recursive implementation and hence, it is defined as a global variable. Alternatively, you could pass it as an argument by reference to the coin method too.
• Thirdly, the denominations entered by the user should be sorted before passing them to the coin method. For this, I have used the sort method from the algorithm library.

What the recursive algorithm basically does is:

• At each step, it considers the largest denomination d (last element in the sorted denomination vector denom like denom[denom.size() - 1]) which is then removed from the vector using pop_back method of vector.
• Using d we find count_d, which is the number of coins of denomination d, used in the solution. We get this by simply applying a div operation like N/d, which gives the Quotient.
• Then d is added to the vector solution, count_d number of times.
• The recursive call, adds count_d from this iteration and recalls coin with the reduced denominations vector denom and Remainder of the amount N using N%d.

See Quotient and Remainder for clarity of what div / and mod % operators do.

Here is the code:

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> solution;

int coin(vector<int> denom, int N)
{
    if(N <= 0 || denom.size() <= 0)
    {
        return 0;
    }

    int d = denom[denom.size() - 1];
    denom.pop_back();

    int count_d = N/d;

    solution.insert(solution.end(), count_d, d);

    return count_d + coin(denom, N%d);
}

int main()
{
    int N,s;
    cout<<"Input a value N:\nInput: ";
    cin>>N;
    cout<<"Input how many denominations:\nInput: ";
    cin>>s;
    vector<int> denom;

    for(int i = 0; i < s; i++)
    {
        int d;
        cout<<"Denominations #"<<i+1<<":\nInput: ";
        cin>>d;
        denom.push_back(d);
    }

    std::sort(denom.begin(), denom.end());

    int minNoOfCoins = coin(denom, N);

    cout<<"\nOutput:\nMinimum # of coins: "<<minNoOfCoins;

    if(minNoOfCoins > 0)
    {
        cout<<"\nCoins used: ";

        for(int i = 0; i < solution.size(); i++)
        {
            if(i > 0)
            {
                cout<<" + ";
            }
            cout<<solution[i];
        }
    }

    cout<<endl;

    system("pause");
}