更多内容，欢迎关注微信公众号：全菜工程师小辉。公众号回复关键词，领取免费学习资料。
动态规划算法一直是面试手撕算法中比较有挑战的一种类型。很多的分配问题或者调度问题实际上都可能用动态规划进行解决。（当然，如果问题的规模较大，有时候会抽象模型使用动归来解决，有时候则可以通过不断迭代的概率算法解决查找次优解）
所以，动归很重要，至少算法思想很重要。
什么是动态规划？
通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。 > 最优子结构：当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。
> 重叠子问题：在用递归算法自顶向下解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。动态规划算法正是利用了这种子问题的重叠性质，对每一个子问题只解一次，而后将其解保存在一个表格中，在以后尽可能多地利用这些子问题的解。
不理解不用怕，结合后面题目来理解这些概念。这些概念完全是已经会动归的人来总结出来的，所以先理解动归，然后再来看这些文绉绉的概括。
分治与动态规划
共同点：
二者都要求原问题具有最优子结构性质，都是将原问题分而治之，分解成若干个规模较小（小到很容易解决）的子问题。然后将子问题的解合并，形成原问题的解。
不同点：
- 分治法将分解后的子问题看成相互独立的，通过用递归来做。
- 动态规划将分解后的子问题理解为相互间有联系，有重叠部分，需要记忆，通常用迭代来做。
动态规划的步骤
问题建模
- 根据问题，找到【最优子结构】。把原问题从大化小的第一步，找到比当前问题要小一号的最好的结果，而一般情况下当前问题可以由最优子结构进行表示。
- 确定问题的【边界】。根据上述的最优子结构，一步一步从大化小，最终可以得到最小的，可以一眼看出答案的最优子结构，也就是边界。
- 通过上述两步，通过分析最优子结构与最终问题之间的关系，我们可以得到【状态转移方程】。
问题求解的各个方法
暴力枚举：
所有的动态规划问题都可以通过多层嵌套循环遍历所有的可能，将符合条件的个数统计起来。只是时间复杂度是指数级的，所以不推荐。
递归：
- 递归的时间复杂度是由递归层数和最优子结构的个数决定的。
- 在爬阶梯问题，最少找零钱问题中，递归的时间复杂度和空间复杂度都比动归方法的差，但是在国王与金矿的问题中，不同的数据规模，动归方法的时间复杂度和空间复杂度不一定比递归的要好。所以具体问题具体分析。
> 上面提到的三个问题是动态规划里很常见的题目，题目内容可以百度查看一下。篇幅原因，本文后边只讲解前两道题
备忘录算法：
- 在阶梯数N比较多的时候，递归算法的缺点就显露出来了：时间复杂度很高。如果画出递归图（像二叉树一样），会发现有很多很多重复的节点。然而传统的递归算法并不能识别节点是不是重复的，只要不到终止条件，它就会一直递归下去。
- 为了避免上述情况，使递归算法能够不重复递归，就把已经得到的节点都存起来，下次再遇到的时候，直接用存起来的结果就行了。这就是备忘录算法。
- 备忘录算法的时间复杂度和空间复杂度都得到了简化。
动态规划算法：
- 上述的备忘录算法，尽管已经不错了，但是依然还是从原问题，遍历得到所有的最小子问题，空间复杂度是O(N)。
- 为了再次缩小空间复杂度，我们可以自底向上的构造递归问题，通过分析最优子结构与最终问题之间的关系，我们可以得到【状态转移方程】。 然后从最小的问题不断往上迭代，即使一直迭代到最大的原问题，也是只依赖于前面的几个最优子结构。这样，空间复杂度就大大简化。也就得到了动归算法算法。
例题
例1: Climbing Stairs(爬楼梯问题)
leetcode原题：你正在爬一个有n个台阶的楼梯，每次只能上1个或者2个台阶，那么到达顶端共有多少种不同的方法？
- 建立模型：
- 最终问题F(N)：假设从0到达第N个台阶的方法共有F(N)个。
- 最优子结构F(N-1)，F(N-2)：到达N个台阶，有两种可能，第一种可能是从第 N-1 个台阶上1个台阶到达终点，第二种可能是从第 N-2 个台阶上2个台阶到达终点。
- 最优子结构与最终问题之间的关系：按照上述表达，那么可以归纳出F(N) = F(N-1) + F(N-2) (n>=3)
- 边界:F(1) = 1,F(2) = 2
- 问题求解：
- 递归：
class Solution {
int climbStairs(int n) {
if (n <= 2) {
return n;
} else {
return climbStairs(n - 1) + climbStairs(n - 2);
}
}
}
> 递归的时间复杂度是由递归层数和最优子结构的个数决定的。这里的阶梯数是 N ，最优子结构个数是2。如果想象成一个二叉树，那么就可以认为是一个高度为N-1，节点个数接近2的N-1次方的树，因此此方法的时间复杂度可以近似的看作是O(2<sup>N</sup>) 。
- 备忘录算法：
这里我们想到了把重复的参数存储起来，下次递归遇到时就直接返回该参数的结果，也就是备忘录算法了，最简单的备忘录就是哈希表。
class Solution {
private Map<integer, integer> map = new HashMap<>();
int climbStairs(int n) {
if (n <= 2) {
return n;
} else if (map.containsKey(n)) {
return map.get(n);
} else {
int value = climbStairs(n - 1) + climbStairs(n - 2);
map.put(n, value);
return value;
}
}
}
- 动态规划：
之前都是自顶向下的求解，考虑一下自底向上的求解过程。从F(1)和F(2)边界条件求，可知F(3) = F(1)+F(2)。不断向上，可知F(N)只依赖于前两个状态F(N-1)和F(N-2)。于是我们只需要保留前两个状态，就可以求得F(N)。相比于备忘录算法，我们再一次简化了空间复杂度。
class Solution {
int climbStairs(int n) {
if (n <= 2) {
return n;
}
// 边界条件
int a = 1;
int b = 2;
int result = 0;
// 最优子结构与最终问题之间的关系
for (int i = 3; i <= n; i++) {
result = a + b;
a = b;
b = result;
}
return result;
}
}
> 空间复杂度O(1), 时间复杂度O(N)
例2: Making change using the fewest coins(最少找零钱问题)
Google面试题：假设你是一家自动售货机制造商的程序员。你的公司正设法在每一笔交易 找零时都能提供最少数目的硬币以便工作能更加简单。已知硬币有四种（1美分，5美分，10美分，25美分）。假设一个顾客投了1美元来购买37美分的物品 ，你用来找零的硬币的最小数量是多少？
- 建立模型：
- 最优子结构：回想找到最优子结构的方法，就是往后退一步，能够得到的最好的结果。这里有四个选择，1 + mincoins(63-1)，1 + mincoins(63-5)，1 + mincoins(63-10) 或者 1 + mincoins(63-25)，这四个选择可以认为是63的最优子结构。
- 状态转移方程：按照上述的最优子结构，mincoins(63)也就等于上述四个最优子结构的最小值。
- 边界: 当需要找零的面额正好等于手中单枚硬币的金额时，返回1即可。
- 问题求解：
- 递归：
class Solution {
Set<integer> coinSet = new HashSet<integer>() {
{
add(1);
add(5);
add(10);
add(25);
}
};
int getFewestCoins(int n) {
if (n < 1) {
return 0;
}
if (coinSet.contains(n)) {
return 1;
}
int minCoins = n;
int numCoins = Integer.MAX_VALUE;
for (int coin : coinSet) {
if (n >= coin) {
// 如果要计算的n小于单个硬币金额，则不能出现在状态转移方程中
numCoins = 1 + getFewestCoins(n - coin);
}
// 更新最小值
if (numCoins < minCoins) {
minCoins = numCoins;
}
}
return minCoins;
}
}
-
备忘录算法：
就是将递归里计算的中间变量都保存在一个哈希表，代码略。 -
动态规划：
自底向上，从找零数等于1开始往上迭代，参考最优子结构，记录下来最少硬币数。一直迭代到实际要求。
class Solution {
Set<integer> coinSet = new HashSet<integer>() {
{
add(1);
add(5);
add(10);
add(25);
}
};
int getFewestCoins(int n) {
int[] list = new int[n + 1];
List<integer> subCal = new ArrayList<>();
for (int i = 0; i <= n; i++) {
// 边界
if (i <= 1) {
list[i] = i;
continue;
}
for (int cent : coinSet) {
if (i >= cent) {
subCal.add(list[i - cent] + 1);
}
}
list[i] = Collections.min(subCal);
subCal.clear();
}
return list[n];
}
}
更多内容，欢迎关注微信公众号：全菜工程师小辉。公众号回复关键词，领取免费学习资料。
</integer></integer></integer></integer></integer></integer,>