Question

为了找到在给定硬币4的情况下对[1,2,3]金额进行更改的方式，我们可以创建一个生成下表的DP算法：

table[amount][coins.count]
        0 1 2 3 4
      -----------
(0) 1 | 1 1 1 1 1
(1) 2 | 1 1 2 2 3
(2) 3 | 1 1 2 3 4

最后一个位置是我们的答案。答案是4，因为我们有以下组合：[1,1,1,1],[2,1],[2,2],[3,1]。

我的问题是，是否可以从我刚刚生成的表中检索这些组合？怎么样？

为了完整性，这是我的算法

func coinChange(coins: [Int], amount: Int) -> Int {
    // int[amount+1][coins]
    var table = Array<Array<Int>>(repeating: Array<Int>(repeating: 0, count: coins.count), count: amount + 1)

    for i in 0..<coins.count {
        table[0][i] = 1
    }

    for i in 1...amount {
        for j in 0..<coins.count {

            //solutions that include coins[j]
            let x = i - coins[j] >= 0 ? table[i - coins[j]][j] : 0
            //solutions that don't include coins[j]
            let y = j >= 1 ? table[i][j-1] : 0

            table[i][j] = x + y
        }
    }
    return table[amount][coins.count - 1];
}

谢谢！

-

解决方案

根据@Sayakiss的解释，这是一个检索组合的丑陋功能：

func getSolution(_ i: Int, _ j: Int) -> [[Int]] {
        if j < 0 || i < 0 {
            //not a solution
            return []
        }
        if i == 0 && j == 0 {
            //valid solution. return an empty array where the coins will be appended
            return [[]]
        }
        return getSolution(i - coins[j], j).map{var a = $0; a.append(coins[j]);return a} + getSolution(i, j - 1)
    }

getSolution(amount, coins.count-1)

输出：

[[1, 3], [2, 2], [1, 1, 2], [1, 1, 1, 1]]

Answer 1

当然可以。我们定义了一个新功能get_solution(i,j)，这意味着您table[i][j] 的所有解决方案。您可以认为它返回一个数组数组，例如，get_solution(4,3)的输出为[[1,1,1,1],[2,1],[2,2],[3,1]]。然后：

案例1。 get_solution(i - coins[j], j)加coins[j]的任何解决方案都是table[i][j]的解决方案。
案例2。 get_solution(i, j - 1)的任何解决方案都是table[i][j]的解决方案。

您可以证明案例1 +案例2是table[i][j]的所有可能解决方案（请注意，通过这种方式获得table[i][j]）。

唯一的问题仍然是实施get_solution(i,j)，我觉得你自己做这件事对你有好处。

如果您还有任何疑问，请不要犹豫，在此发表评论。

DP硬币更改算法 - 从表

1 个答案: