Java 动态规划-做出改变

我很难找出动态硬币兑换问题的最后一段代码。我已经包括了下面的代码

我想不出最后一个

还有什么
。我应该在这一点上使用贪婪算法，还是可以根据表中已有的值计算答案？我一直在努力理解这个问题，我想我已经很接近了。该方法通过创建一个表并使用存储在表中的结果来解决更大的问题，而不使用递归，从而找到进行一定数量更改所需的最小硬币数量

public static int minCoins(int[] denom, int targetAmount){
    int denomPosition; // Position in denom[] where the first spot
                       // is the largest coin and includes every coin
                       // smaller.
    int currentAmount; // The Amount of money that needs to be made
                       // remainingAmount <= initalAmount
    int[][] table = new int[denom.length][targetAmount+1];
    for(denomPosition = denom.length-1 ; denomPosition >= 0 ; denomPosition--) {
        for(currentAmount = 0 ; currentAmount <= targetAmount ; currentAmount++){
            if (denomPosition == denom.length-1){
                table[denomPosition][currentAmount] = 
                     currentAmount/denom[denomPosition];
            }
            else if (currentAmount<denom[denomPosition]){
                table[denomPosition][currentAmount] = 
                     table[denomPosition+1][currentAmount];
            }
            else{           
                table[denomPosition][currentAmount] = 
                     table[denomPosition+1][currentAmount]-
                     table[denomPosition][denom[denomPosition]]-1;
            }
        }
    }
    return table[0][targetAmount];
}

public static int minCoins（int[]denom，int targetAmount）{
int denomPosition；//在denom[]中第一个点所在的位置
//是最大的硬币，包括所有硬币
//小一点。
int currentAmount；//需要赚的钱的数量
//remainingAmount=0；反合成--）{
对于（currentAmount=0；currentAmount您是否考虑过度了？如果我们试图用美国硬币兑换68美分的零钱

“denom”是{25,10,5,1}吗

答案不是“2个25美分、1个10美分、1个5美分和3个便士”='2+1+1+3=7'？所以函数应该返回值7。对吗？
解决换币问题不需要切换到贪婪算法，可以使用动态编程算法来解决。例如：

public int minChange(int[] denom, int targetAmount) {

    int actualAmount;
    int m = denom.length+1;
    int n = targetAmount + 1;
    int inf = Integer.MAX_VALUE-1;

    int[][] table = new int[m][n];
    for (int j = 1; j < n; j++)
        table[0][j] = inf;

    for (int denomPosition = 1; denomPosition < m; denomPosition++) {
        for (int currentAmount = 1; currentAmount < n; currentAmount++) {
            if (currentAmount - denom[denomPosition-1] >= 0)
                actualAmount = table[denomPosition][currentAmount - denom[denomPosition-1]];
            else
                actualAmount = inf;
            table[denomPosition][currentAmount] = Math.min(table[denomPosition-1][currentAmount], 1 + actualAmount);
        }
    }

    return table[m-1][n-1];

}

public int minChange（int[]denom，int targetAmount）{
实际数；
int m=名称长度+1；
int n=目标安装+1；
int inf=Integer.MAX_值-1；
int[][]表=新的int[m][n]；
对于（int j=1；j=0）
实际金额=表[denomPosition][currentAmount-denom[denomPosition-1]]；
其他的
实际数量=inf；
表[Denomposion][currentAmount]=数学最小值（表[Denomposion-1][currentAmount]，1+实际数量）；
}
}
返回表[m-1][n-1]；
}
这实际上是该算法的正确版本

public static int minChange(int[] denom, int targetAmount) {
    int actualAmount;
    int m = denom.length + 1;
    int n = targetAmount + 1;
    int inf = Integer.MAX_VALUE - 1;

    int[][] table = new int[m][n];
    for(int i = 0; i< m; ++i) {
        for (int j = 1; j < n; j++) {
            table[i][j] = inf;
        }
    }

    for (int denomPosition = 1; denomPosition < m; denomPosition++) {
        for (int currentAmount = 1; currentAmount < n; currentAmount++) {
            if (denom[denomPosition-1] <= currentAmount) {
                // take
                actualAmount = table[denomPosition][currentAmount - denom[denomPosition-1]];
            }
            else {
                actualAmount = inf;
            }                                              // do not take
            table[denomPosition][currentAmount] = Math.min(table[denomPosition-1][currentAmount], 1 + actualAmount);
        }
    }

    return table[m-1][n-1];
}

public static int minChange（int[]denom，int targetAmount）{
实际数；
int m=最小长度+1；
int n=目标安装+1；
int inf=Integer.MAX_值-1；
int[][]表=新的int[m][n]；
对于（int i=0；i//这非常有效。。。
public int minChange（int[]denom，int targetAmount）
{
实际数；
int m=名称长度+1；
int n=目标安装+1；
int inf=Integer.MAX_值-1；
int[][]表=新的int[m][n]；
对于（int j=1；j=0）//取此面额值并从当前金额中减去此值
表[i][j]=数学最小值（表[i-1][j]，1+表[i][j-最小值[i-1]]）；
其他的
表[i][j]=表[i-1][j]；
}
}
//显示阵列
System.out.println（“----------------------显示二维矩阵（面额和金额）------------”）；
for（int i=0；i
数组denom可以包含任意数量的任意值的“硬币”，例如，denom可以是{26,11,9,6,1}，程序的要点是找到制作“targetMount”所需的最小硬币数量，因此如果数组denom包含{10,6,1}且targetMount=12，则该方法假定返回2（2x6），而不是3（10+1+1）这种方法可以工作，但不能帮助我理解问题。你或其他人可以对代码的关键行发表意见吗？我看到的for循环用于去成分和currentAmount，但在那之后，它与我的原始程序失去了所有的相似性。谢谢你的帮助。我的实现是基于“进行更改”在中解释的问题，在观看链接中的视频后应该清楚
//this works perfectly ...

 public int minChange(int[] denom, int targetAmount) 
    {

    int actualAmount;
    int m = denom.length+1;
    int n = targetAmount + 1;
    int inf = Integer.MAX_VALUE-1;

    int[][] table = new int[m][n];
    for (int j = 1; j < n; j++)
        table[0][j] = inf;

    for (int i = 1; i < m; i++) //i denotes denominationIndex
    {
        for (int j = 1; j < n; j++) //j denotes current Amount
        {
            if (j - denom[i-1] >= 0)//take this denomination value and subtract this value from Current amount

                table[i][j] = Math.min(table[i-1][j], 1 + table[i][j - denom[i-1]]);

            else
                table[i][j] = table[i-1][j];

        }
    }




    //display array
        System.out.println("----------------Displaying the 2-D Matrix(denominations and amount)----------------");
        for (int i = 0; i < m; i++) 
        {
            System.out.println("   ");
            for (int j = 0; j < n; j++) 
            {
                System.out.print("  "+table[i][j]);

            }
            System.out.println("   ");
        }

    return table[m-1][n-1];

}