C++ 将递归解决方案更改为动态规划解决方案

在这里，我试图将递归解转换为动态解，但在转换过程中遇到了问题。我试图计算出尽可能少的硬币来创造价值。我所做的是，我把所有可能的硬币放入一个向量中，最后在主函数中，我会找到向量的最小值，这就是我的答案

int rec(vector<int>coins,int n,int sum,int counter)
{
     if(sum==0)
     {
         return 1;
     }
     if(n==0)
     {
         return 0;
     }
     int total=rec(coins,n-1,sum,counter);
     if(sum-coins[n-1]>=0)
     {
         total+=rec(coins,n,sum-coins[n-1],counter+1);
         if(sum-coins[n-1]==0)
         {
              vec.push_back(counter+1);
         }
     }
     return total;
}    

int rec（向量硬币、int n、int和、int计数器）
{
如果（总和=0）
{
返回1；
}
如果（n==0）
{
返回0；
}
int total=rec（硬币，n-1，总和，计数器）；
如果（总硬币[n-1]>=0）
{
总计+=记录（硬币，n，总硬币[n-1]，计数器+1）；
如果（总硬币[n-1]==0）
{
向量推回（计数器+1）；
}
}
返回总数；
}    

您应该首先尝试自己解决这类问题

顺便说一句：

#定义大2147483647
整数最小值硬币（整数*硬币，整数m，整数欲望值）
{
int dp[期望值+1]；
dp[0]=0；
对于（int i=1；i取决于硬币的价值，您不需要动态规划，因为贪婪的选择就足够了。谢谢您的回答，但我可以轻松地完成您提供的解决方案…但我担心的是在我的dp解决方案中调整计数器太多
#define BIG 2147483647

int min_coin(int *coins, int m, int desire_value)
{
    int dp[desire_value+1];

    dp[0] = 0;
 
    for (int i=1; i<=desire_value; i++)
        dp[i] = BIG;
 
    for (int i=1; i<=desire_value; i++)
    {
        for (int j=0; j<m; j++)
          if (coins[j] <= i)
          {
              int diff = dp[i-coins[j]];
              if (diff != BIG && diff + 1 < dp[i])
                  dp[i] = diff + 1;
          }
    }
   
      if(dp[desire_value]==BIG)
        return -1;
   
    return dp[desire_value];
}