Convert inefficient recursive coin change function to iteration - c++

Question

I have an inefficient recursive coin change function that works out the number of coin combinations for a given amount. I would like to convert it to a more efficient iterative function if possible.
One problem is that I am using backtracking to try out different coins in an array called denominations. I am also using memoization but it doesn't speed things up when the amount is large.
Here's my code:
unsigned long long CalculateCombinations(std::vector<double> &denominations, std::vector<double> change,
double amount, unsigned int index)
{
double current = 0.0;
unsigned long long combinations = 0;
if (amount == 0.0)
{
if (change.size() % 2 == 0)
{
combinations = Calculate(change);
}
return combinations;
}
// If amount is less than 0 then no solution exists
if (amount < 0.0)
return 0;
// If there are no coins and index is greater than 0, then no solution exist
if (index >= denominations.size())
return 0;
std::string str = std::to_string(amount) + "-" + std::to_string(index) + "-" + std::to_string(change.size());
auto it = Memo.find(str);
if (it != Memo.end())
{
return it->second;
}
while (current <= amount)
{
double remainder = amount - current;
combinations += CalculateCombinations(denominations, change, remainder, index + 1);
current += denominations[index];
change.push_back(denominations[index]);
}
Memo[str] = combinations;
return combinations;
}
Any ideas how this can be done? I know there are DP solutions for coin change problems, but mine doesn't lend itself easily to one. I can have half pennies.
*Update: I changed the function to be iterative and I scaled up by a factor of 2 to use integers, bit it made no considerable difference.
Here's my new code:
unsigned long long CalculateCombinations(std::vector<int> &denominations, std::vector<int> change, int amount, unsigned int index)
{
unsigned long long combinations = 0;
if (amount <= 0)
return combinations;
std::stack<Param> mystack;
mystack.push({ change, amount, index });
while (!mystack.empty())
{
int current = 0;
std::vector<int> current_coins = mystack.top().Coins;
int current_amount = mystack.top().Amount;
unsigned int current_index = mystack.top().Index;
mystack.pop();
if (current_amount == 0)
{
if (current_coins.size() % 2 == 0)
{
combinations += Calculate(std::move(current_coins));
}
}
else
{
std::string str = std::to_string(current_amount) + "-" + std::to_string(current_index);
if (Memo.find(str) == Memo.end())
{
// If amount is less than 0 then no solution exists
if (current_amount >= 0 && current_index < denominations.size())
{
while (current <= current_amount)
{
int remainder = current_amount - current;
mystack.push({ current_coins, remainder, current_index + 1 });
current += denominations[current_index];
current_coins.push_back(denominations[current_index]);
}
}
else
{
Memo.insert(str);
}
}
}
}
return combinations;
}
Memo is defined as std::unordered_set.
Can this be solved by DP? The problem is that I'm not interested in all combinations - only combinations that are even in size.

Answer 1

I don't see any strategy in your code that discards denominations.
My recursive answer would be at each recursive stage to create 2 children:
1 child uses the full list of denominations, and spends 1 of the end denomination
The second child discards the same end denomination
They each recurse, but in the second case the children have one less denomination to work with.
I believe the results returned are all distinct, but of course you do get the pain case where you recurse 10000 levels deep to get $100 in pennies. This can easily be optimised for when you get down to 1 denomination, and probably indicates that it is best to process and discard higher denominations in each round rather than lower denominations.
You can also detect the case where all remaining denominations are simple multiples of each other and quickly generate the permutations without doing the full recursion: Generate the minimum coin set (max of each high denomination) then work backward replacing each coin with numbers of smaller coins.