硬币改变 dp 解决方案 - 为什么迭代循环的顺序很重要

Question

为什么迭代循环的顺序在这里很重要？

    def change1(self, amount, coins):
        """
        :type amount: int
        :type coins: List[int]
        :rtype: int
        """
        if amount == 0:
            return 1

        dp = [0 for _ in range(amount + 1)]
        dp[0] = 1

        # dp[i] to denote the number of ways to sum up to amount i.
        for j in range(len(coins)): # switch those 2 statements would be wrong answer why???
            for i in range(1, amount + 1):
                if i - coins[j] >= 0:
                    dp[i] += dp[i - coins[j]]

        return dp[amount]

    def change2(amount, coins): # wrong answer
        """
        :type amount: int
        :type coins: List[int]
        :rtype: int
        """
        if amount == 0:
            return 1

        dp = [0 for _ in range(amount + 1)]

        ## when amount is 0, # combinations is 1
        dp[0] = 1

        # dp[i] to denote the number of ways to sum up to amount i.
        for i in range(1, amount + 1):
            for j in range(len(coins)):  # switch those 2 statements would be wrong answer why???
                if i - coins[j] >= 0:
                    dp[i] += dp[i - coins[j]]

        return dp[amount]

更改 1

dp[i-1] = dp[i-1-c2] + dp[i-1-c2] + dp[i-2-c2] + ..dp[0]

dp[i] = dp[i-c1] + dp[i-1-c1] + dp[i-2-c1] + ...dp[0] 这是正确的解决方案。

更改 2

dp[i-1] = dp[i-1-c1] + dp[i-1-c2] + dp[i-1-c3] + dp[i-1-c4] + ... dp[0]

dp[i] = dp[i-c1] + dp[i-c2] + dp[i-c3] + dp[i-c4] + ... dp[0]

为什么这种方法是错误的？

总金额i可以从取币c1或c2或c3的选择总和得出，我认为这更直观。

我检查了一些参考资料，但找不到令人满意的答案。

编辑：我也明白改变嵌套循环的顺序会给出错误的答案，我试图理解为什么第二种方法有错误的直觉，而第一种方法是正确的。

Coin Change: number of solutions when order matters vs. when order doesn't matter

Coin change using dynamic programming

Answer 1

显然，当您更改嵌套循环的顺序时，它必须给出错误的答案。

问题的正确dp状态定义如下：

dp[i][j] = # of ways to form amount j using first i coins

这里的最佳子结构是，一旦你有了第一个i 硬币的解决方案，你就可以将它扩展到i+1 硬币。

但是当你翻转循环的执行顺序时，这个子结构属性就不成立了。

在这种情况下，您首先使用所有硬币计算形成金额i 的方式数，并将其扩展以找到形成金额i+1 的方式数，其中最优子结构属性不成立真的。