C++ 彻底搜索：最小硬币数量的变化。使用递归时保留解数组

问题在于尽量减少所需的硬币数量，以提供准确的变化。总会有1的硬币可用，因此问题总会有解决办法

一些样品硬币套装及其解决方案的价格为40美分：

硬币组={1,5,10,20,25}，解决方案={0,0,0,2,0}

硬币组={1,5,10,20}，解决方案={0,0,0,2}

该实现返回正确的最小硬币数，但我在保存正确的解决方案数组时遇到问题

int change(int amount, int n, const int* coins, int* solution) {
    if(amount > 0) {
        int numCoinsMin = numeric_limits<int>::max();
        int numCoins;
        int imin;
        for(int i = 0; i != n; ++i) {
            if(amount >= coins[i]) {
                numCoins =  change(amount - coins[i], n, coins, solution) + 1;
                if(numCoins < numCoinsMin) {
                    numCoinsMin = numCoins;
                    imin = i;
                }   
            }   
        }   
        solution[imin] += 1;
        return numCoinsMin;
    }   
    return 0;
}

整数变化（整数金额、整数n、常数整数*硬币、整数*解决方案）{
如果（金额>0）{
int numCoinsMin=numeric_limits:：max（）；
国际货币基金组织；
int imin；
对于（int i=0；i！=n；++i）{
如果（金额>=硬币[i]）{
numCoins=变化（数量-硬币[i]，n，硬币，溶液）+1；
if（numCoins

样本运行：

int main() {
    const int n = 4;
    int coins[n] = {1, 5, 10, 20, 25};
    int solution[n] = {0, 0, 0, 0, 0};
    int amount = 40;

    int min = change(amount, n, coins, solution);
    cout << "Min: " << min << endl;
    print(coins, coins+n); // 1, 5, 10, 20
    print(solution, solution+n); // 231479, 20857, 4296, 199
    return 0;
}

intmain（）{
常数int n=4；
整数硬币[n]={1,5,10,20,25}；
int解[n]={0,0,0,0,0}；
整数金额=40；
int min=变化（数量、n、硬币、溶液）；
cout您仍然可以使用数组来实现这一点，但是我会改变程序的结构，使其递归更干净一些

我必须为你做伪代码，因为我根本不使用C++，但你可以把它放在一起。这就使用了模分（C中的%，如果没有在C++中，你可以查一下），它只返回除法的剩余部分。在大多数编程语言中，将返回整数答案并忽略任何余数

//declare a function that takes in your change amount and the length of your coins array
int changeCounter(int amount, int coins.length)
      int index = coins.length-1;

      //check to see if we're done... again dunno what 'or' is in C++, I put ||

      if (amount <= 0 || index < 0)
         **return** your results array or whatever you want to do here

      //sees how many of the biggest coin there are and puts that number in the results
      if amount > coins[index]
      {
        result[index]= (amount / coins[index])
        //now recurse with the left over coins and drop to the next biggest coin
        changeCounter((amount % coins[index]), index-1)
      }

      //if the amount isnt greater than the coin size then there obviously arent any of that size, so just drop coin sizes and recurse again
      else
         changeCounter(amount,index-1)

//声明一个函数，该函数接受您的零钱金额和硬币数组的长度
整数兑换计数器（整数金额，整数硬币长度）
整数指数=硬币长度-1；
/检查我们是否完成了……再次不知道C++中的“或”是什么，我把
if（货币数量[指数]
{
结果[索引]=（金额/硬币[索引]）
//现在与剩余的硬币一起循环，并下降到下一个最大的硬币
兑换计数器（（金额百分比硬币[索引]），索引-1）
}
//如果数量不大于硬币大小，那么显然没有任何大小的硬币，所以只需丢弃硬币大小并再次循环
其他的
变更计数器（金额，索引-1）

<>这应该让你开始正确的方向，我试着给你评论，我很抱歉我不能把它完美的C++语法给你，但是我不应该太难把我在这里做的事情翻译成你想要做的。
如果您有任何问题，请告诉我
您是否可以更具体地说明您希望发生的事情？我不确定您所说的“保留正确的解决方案数组”是什么意思。使用示例运行更新了问题。例如，当我运行40次时，解决方案数组应为0、0、0、2。表示只需要2枚20美分的硬币.但我得到的是那些大数字。这个问题除了递归之外还需要什么吗？比如你必须使用数组吗？我问的原因是，我不确定我会这样做，除非你因为某种原因被迫使用数组。不，我没有被迫使用数组。我更新了我的答案，现在它解决了问题。我只是试着评论一下如果你仍然需要找到硬币总数的最小值，只需在完成的结果数组中循环并添加值。或者你可以在函数中保留一个变量，在进行数学运算时向其添加结果值。我有一个问题：这不是贪婪的方法吗？例如，如果我的硬币集合是{1,5,10,20,25}数量是40。它会选择25个硬币中的1个，然后选择20个硬币中的1个，然后选择5个硬币中的1个。而不是20个硬币中的2个。我没有意识到你想要最小化你得到的硬币的总数，我只是认为你想要有效地进行兑换。这使得这比我在午餐休息时花时间回答它更复杂。看起来会有点奇怪如果到那时还没人接电话，我到家后就有收获了。