一个简单的例子由易到难理解动态规划

在本文中，我们先用最简单的方法来解决问题，然后一步步进阶，在这个不断优化算法的过程中理解动态规划。

力扣 322. 零钱兑换 问题

1. 给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
2. 计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。【你可以认为每种硬币的数量是无限的。】

public int coinChange(int[] coins, int amount) {

}

1. 暴力递归

假设 coins[] = [2, 4, 5]，amount = 10，想要求 amount = 10 可以求
min ( 1 + coinChange(coins, amount - 2), 1 + coinChange(coins, amount - 4), 1 + coinChange(coins, amount - 5) )

即假设已经知道了 amount = 8、amount = 6、amount = 5 时 所需的最少的硬币个数， 那只要再加 1 个硬币就可以凑够 10，在这三者中选最少的一个就是答案。

继续想的话，求 amount = 8，也是同样的方法，就是不断往下递归。

public int coinChange(int[] coins, int amount) {
	//确定递归结束的条件
	if(amount == 0) return 0;
	if(amount < 0) return -1;
	
	int res = Integer.MAX_VALUE;
	//遍历求各 coinChange(amount-coin) 的值，求出最小值
	for(int coin: coins){
		int subProblem = coinChange(coins, amount-coin);
		if(subProblem == -1) continue;
		res = Math.min(res, subProblem + 1);
	}
	return res==Integer.MAX_VALUE ? -1 : res;
}

为了更好理解，来画一下递归树

从上图就可以看出来，这种方法就是在用递归把所有的可能穷举出来，然后取最小值。

但这个方法存在重叠子问题，即存在大量的重复计算。有很多问题我们已经计算过，但当递归到那里时，还是要再算一次。

所以为解决这个问题，下面采用带备忘录的递归解法。

2. 带备忘录的递归解法

带备忘录就是把已经计算过的值存起来，以此来减少不必要的计算。

每次计算完后，将值存入一个数组中，每次计算前判断一下备忘录中有没有存，有则可以直接获取，不需要再进行漫长的递归运算了。

int[] count;
public int coinChange(int[] coins, int amount) {
    //建立数组，进行初始化
    count = new int[amount+1];
    Arrays.fill(count, -2);
    return(coin(coins, amount));
}
public int coin(int[] coins, int amount){
    if(amount == 0) return 0;
    if(amount < 0) return -1;
        
    //判断是否存入备忘录
    if(count[amount] != -2)
        return count[amount];
    int res = Integer.MAX_VALUE;
            
    for(int coin:coins){
        int subProblem = coin(coins, amount-coin);
        if(subProblem == -1) continue;
        res = Math.min(res, subProblem+1);
    }
 	//存入
    count[amount] = (res == Integer.MAX_VALUE) ? -1 : res;
    return count[amount];
}

现在似乎已经很完善了，但备忘录解法是 自顶向下 的，是从一个规模较大的原问题，一层一层向下分解成子问题，直至底层，然后再逐层返回结果。

动态规划是 自底向上 的解出最优值。下面来改造一下这个方法。

3. dp 数组的迭代解法

采用 自底向上 就是要从底层状态一直算到所求状态
定义一个 dp 数组，dp[i] 表示为 amount = i 时所需的最少的硬币个数

public int coinChange(int[] coins, int amount) {
	int[] dp = new int[amount + 1];
    Arrays.fill(dp, amount + 1);
	
	dp[0] = 0;
	// 外层 for 循环在遍历所有状态的所有取值
	// 然后存入 dp[i] 中
	for(int i=1; i<dp.length; i++){
		for(int coin: coins){
			if(i-coin < 0) continue;
			dp[i] =Math.min(dp[i], 1 + dp[i-coin]);
		}
	}
	return dp[amount] == amount + 1 ? -1 : dp[amount];
}

这就是最后的动态规划的解法了。

动态规划最核心的是写出状态转移方程，这也是最困难的一步，多多练习，熟能生巧。

本文源于学习 labuladong的算法小抄 ，大佬写的明白易懂，没有什么晦涩的地方。