找零钱是一个经典的动态规划问题。这种问题，我建议，首先学会暴力解法，然后从暴力解法中优化出动态规划的解法，这样，更能体会动态规划的魅力。
问题描述
有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]
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]
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()
总结
动态规划是面试中的常考技能点。我推荐的学习路径就是这种，先学会暴力算法，然后利用缓存，去掉重复计算，然后学习以缓存填充为核心的动态规划。