动态规划之找零钱问题

vlambda
2020-09-21

动态规划之找零钱问题

找零钱是一个经典的动态规划问题。这种问题，我建议，首先学会暴力解法，然后从暴力解法中优化出动态规划的解法，这样，更能体会动态规划的魅力。

问题描述

有n种不同币值的硬币，硬币数量无限。给定一个数量T，求用给定硬币凑出T的方法数量。

举个例子：

假设币值是: {1,2,3}

给定的T值: 5

输出所有的组合数量: 5

为啥是5呢，因为有5种不同的组合可以得到数值5，如下所示：

{1,1,1,1,1}
{1,1,1,2}
{1,2,2}
{1,1,3}
{2,3}

暴力解法

既然这是要找所有的组合数量，暴力搜索就是很自然的想法了。暴力搜索算法写起来有两个关键点：

记下已经搜索到的结果，并且越简单越好，因为空间占用小啊。
记下剩余可用的搜索空间

简单说，就是我已经有了什么，我还可以有什么。

这两点，会因为具体问题不同而有不同的表现形式。

对这道凑币值的问题。我们的暴力搜索问题，可以看作是往一个布袋中放硬币，直到布袋中硬币的币值之和等于要求的数量。

看起来，布袋中的硬币就是我们已经搜索到的结果。剩余可选的硬币和还需要凑的币值就是我们可用的搜索空间。

这个虽然没有问题。但是我们需要一个数组来存储布袋中的硬币，这个空间开销还是不小。而且，这个问题并不要求我们给出具体的组合方案，而是只要所有可能的组合数量。鉴于此，我们可以做一个优化：将已经搜索到的结果用还需要凑的币值来表示显然，这个值可以完美代表我们已有的搜索成果。

将所有可选的硬币币值放入一个数组，那么剩余可选的硬币就可以用一个index来代替。

最后，暴力搜索的终点，无非两种，一种就是找到了一种拼凑方案，一种就是没有。

把这些问题想清楚。写代码时就轻松了。

代码实现

class CoinChange {
'''
@denominations：代表所有可用的币值
@total：代表要拼凑的数值
'''
 public int countChange(int[] denominations, int total) {
 return this.countChangeRecursive(denominations, total, 0);
 }

'''
@total：代表剩余还要拼凑的币值
@currentIndex：代表剩余可用的硬币币值
'''
 private int countChangeRecursive(int[] denominations, int total, int currentIndex) {
 # 找到一个拼凑方案，返回1，用于累加
 if (total == 0)
 return 1;
 # 到达搜索终点，不是可用的拼凑方案，返回0
 if(denominations.length == 0 || currentIndex >= denominations.length)
 return 0;

 # 递归进行暴力搜索，如果currentIndex处的币值小于total
 # 则有两个选择：
 # 将该币值放入布袋，即从total中减去该币值，然后继续搜索，
 # 此时剩余可用币值不减少
 # 不使用该币值，继续搜索，此时剩余可用币值要减去currentInde # x处的币值
 int sum1 = 0;
 if( denominations[currentIndex] <= total )
 sum1 = countChangeRecursive(denominations, total - denominations[currentIndex], currentIndex);

 // recursive call after excluding the coin at the currentIndex
 int sum2 = countChangeRecursive(denominations, total, currentIndex + 1);

 return sum1 + sum2;
 }

 public static void main(String[] args) {
 CoinChange cc = new CoinChange();
 int[] denominations = {1, 2, 3};
 System.out.println(cc.countChange(denominations, 5));
 }
}

从上到下记忆

理解了暴力搜索算法，将里面的重复计算消除，就是动态规划了。观察上面的代码，可以发现，递归调用的两个关键参数 total和currentIndex一旦确定，则该递归调用的结果就是确定的。这两个参数在暴力搜索中显然被会有重复的使用。这就是我们要消除的重复计算。

方法很简单，做个缓存就可以了。因为两个参数，用二维数组自然很合适。

class CoinChange {

 public int countChange(int[] denominations, int total)
 {
 Integer[][] dp = new Integer[denominations.length][total + 1];
 return this.countChangeRecursive(dp, denominations, total, 0);
 }

 private int countChangeRecursive(Integer[][] dp, int[] denominations, int total, int currentIndex)
 {
 
 if (total == 0)
 return 1;

 if(denominations.length == 0 || currentIndex >= denominations.length)
 return 0;

 # 缓存中有结果，直接返回即可
 if(dp[currentIndex][total] != null)
 return dp[currentIndex][total];

 # 缓存中没有，继续进行递归计算
 int sum1 = 0;
 if( denominations[currentIndex] <= total )
 sum1 = countChangeRecursive(dp, denominations, total - denominations[currentIndex], currentIndex);

 
 int sum2 = countChangeRecursive(dp, denominations, total, currentIndex + 1);

 dp[currentIndex][total] = sum1 + sum2;
 return dp[currentIndex][total];
 }

 public static void main(String[] args) {
 CoinChange cc = new CoinChange();
 int[] denominations = {1, 2, 3};
 System.out.println(cc.countChange(denominations, 5));
 }
}

自下而上动态规划

有了以上两种方法的铺垫，再来看真正的动态规划。我们就可以理解动态规划是要更彻底的解决问题。在我们从上到下加记忆的方法中，我们使用了缓存，来存储中间结果。动态规划的思路，其实就是将缓存作为关键，将问题的求解转化为填充缓存的过程。

比如，我们现在要填充缓存dp[currentIndex][t]。这个缓存代表的问题，有两类可能的组合方案：

没有currentIndex币值的方案，这样的方案的数量就是dp[currentIndex-1][t]
至少包含一个currentIndex币值的方案，这样的方案的数量就是dp[currentIndex][t-denominations[currentIndex]]

将这两种方案的数量加起来就是dp[currentIndex][t]的值了。

有了上面的分析，代码就是手到擒来。

def count_change(denominations, total):
  n = len(denominations)
  dp = [[0 for _ in range(total+1)] for _ in range(n)]

  # 填充total为0时数值，始终有1个方案
  for i in range(n):
    dp[i][0] = 1

  # 双重循环填充缓存
  for i in range(n):
    # total=0的情况已经专门填充，这里从1开始
    for t in range(1, total+1):
      if i > 0:
        dp[i][t] = dp[i - 1][t]
      if t >= denominations[i]:
        dp[i][t] += dp[i][t - denominations[i]]

  # 右下角就是最终结果
  return dp[n - 1][total]


def main():
  print(count_change([1, 2, 3], 5))


main()

总结

动态规划是面试中的常考技能点。我推荐的学习路径就是这种，先学会暴力算法，然后利用缓存，去掉重复计算，然后学习以缓存填充为核心的动态规划。

vlambda博客
学习文章列表