Java 开始动态规划-贪婪硬币更改帮助

我目前正在阅读一本关于算法设计的书，遇到了一个问题，即必须使用动态规划实现贪婪算法来解决硬币兑换问题

我试图实现这一点，但我无法理解或理解书中给出的算法。算法如下（我在评论中（缺乏）理解）：

Change（p）{
C[0]=0
对于（i=1到p）//从1循环到我们想要的变化值，p
最小值=无穷大
对于（j=1到k（//从1到。。。？
如果dj动态规划的本质是将问题分解为子问题，然后开始向上构建解决方案。其思想是如果你解决“n”子问题您可以将它们组合起来，这种组合将是整个问题的解决方案。递归是动态编程的一个例子，只是它会遇到潜在的堆栈溢出问题。另一种技术称为记忆，它缓存结果以加快查找时间，而不是重新计算已计算的问题。这节省了大量处理并加快了程序。至于贪婪换币问题，其实质是寻找最大面额并使用它，直到它不能再使用为止（即，将总金额重复除以最大面额，并跟踪剩余部分）然后转到下一个最大值，重复相同的过程，直到剩下最小值所能代表的最小值为止。您可以一直将最小值存储在数组中，并在发现新的最小值时不断更新它（即记忆）。如果我在某个地方出错，我希望人们能纠正我

编辑：但是请注意，并不是所有的问题都可以用动态规划来解决，动态规划与任何编程语言都没有任何关系，它只是用来解决优化问题的技术的一个名称。
这似乎是硬件问题，所以我将给出一些建议。首先要做的是解决DP的问题是“自上而下思考，自下而上解决”

“自上而下思考”-这是建立递归关系的部分

对于例如：T（n）=0，如果n参见此

摘录：

贪婪的选择属性我们可以在最短的时间内做出任何看起来最好的选择
然后解决随后出现的子问题。选择
贪婪算法所做的选择可能取决于迄今为止所做的选择，但并非如此
关于未来的选择或子问题的所有解决方案
迭代地做出一个又一个贪婪的选择，减少每个给定的
把问题分解成更小的问题。换句话说，贪婪算法永远不会
重新考虑它的选择。这是与动态的主要区别
编程，这是详尽的，并保证找到
解决方案。在每个阶段之后，动态规划基于
对上一阶段作出的所有决定，可重新考虑
前一阶段的算法路径

您的代码在
int p
中迭代，获得最佳选择并将其放入数组
tempArray
中，然后在下一次迭代中使用此值检查最佳选择。
到派对时有点晚，但您的函数已经起作用了

public static int change(int[] d, int p) {
    // tempArray to store set of coins forming answer
    int[] tempArray = new int[Integer.MAX_VALUE];

    tempArray[0] = 0; // INITIAL STEP MISSING

    for (int i = 1; i <= p; ++i) { // cycling up to the wanted value
        // assigning current minimum number of coins
        int min = Integer.MAX_VALUE;

        // cycling through possible values
        for (int value : d) {

            if (value <= i) { // FIX missing = in <=

                // if current value is less than min
                if (1 + tempArray[i - value] < min) {

                    // FIX, it's [i-value] not [1-value]
                    min = 1 + tempArray[i - value];
                }
            }
        }
        tempArray[i] = min; // assign min value to array of coins
    }
    return tempArray[p];
}

我试图理解“动态规划”这个术语的用法在这种情况下，你能解释一下吗？动态规划是一种解决问题的技术，在这个问题中，以前的解决方案用于计算以后的解决方案。一般的硬币兑换问题是，给定指定面额的硬币和一个数字N，为N兑换所需的最小硬币数量是多少。“用动态规划实现贪婪算法”-它要么是贪婪算法要么是DP算法。。。
/**
     * 
     * @param d
     *            currency divisions
     * @param p
     *            target
     * @return number of coins
     */
    public static int change(int[] d, int p) {
        int[] tempArray = new int[Integer.MAX_VALUE]; // tempArray to store set
                                                        // of coins forming
                                                        // answer
        for (int i = 1; i <= p; i++) { // cycling up to the wanted value
            int min = Integer.MAX_VALUE; //assigning current minimum number of coints
            for (int value : d) {//cycling through possible values
                if (value < i) {
                    if (1 + tempArray[i - value] < min) { //if current value is less than min
                        min = 1 + tempArray[1 - value];//assign it
                    }
                }
            }
            tempArray[i] = min; //assign min value to array of coins
        }
        System.out.println("help"); // :(
        return tempArray[p];
    }

public static int change(int[] d, int p) {
    // tempArray to store set of coins forming answer
    int[] tempArray = new int[Integer.MAX_VALUE];

    tempArray[0] = 0; // INITIAL STEP MISSING

    for (int i = 1; i <= p; ++i) { // cycling up to the wanted value
        // assigning current minimum number of coins
        int min = Integer.MAX_VALUE;

        // cycling through possible values
        for (int value : d) {

            if (value <= i) { // FIX missing = in <=

                // if current value is less than min
                if (1 + tempArray[i - value] < min) {

                    // FIX, it's [i-value] not [1-value]
                    min = 1 + tempArray[i - value];
                }
            }
        }
        tempArray[i] = min; // assign min value to array of coins
    }
    return tempArray[p];
}

public static void main(String[] args) {
    int[] coins = new int[] { 25, 12, 10, 5, 1 };

    int coinCount = change(coins, 15);
    System.out.println("min change: " + coinCount);
}