曾经的我以为动态规划很神秘，很难理解。后来随着刷的动态规划相关的题越来越多，对于动态规划也就驾轻就熟了。我一开始来认识动态规划是通过概念来理解的，这对于我来说总是显得晦涩。我不是一个善于死记理论的人，反而是通过多刷题，回头再去看动态规划的使用情况则是有一种恍然大悟感。这样的获得想必也不会轻易忘记。刷题并不能让人变得聪明，但确实能够锻炼一个人的思维。
递归 + 数组 = 动态规划
先看一眼概念也未必是坏事：动态规划 - 维基百科，自由的百科全书
动态规划的所有题目，在不考虑性能的情况下，都可以使用简单的递归来解决。
题目
下面来看一道 LeetCode 经典动态规划题目：(70) Climbing Stairs - LeetCode
You are climbing a stair case. It takes n steps to reach to the top.
Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
Note: Given n will be a positive integer.
Example 1:
Input: 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps
Example 2:
Input: 3
Output: 3
Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step
递归
公式如下（这个也是做动态规划必须要列出的公式）
我们来试试用简单的递归来解决这个问题：
/**
* Created by jacob on 2019-08-20.
*/
public class Solution {
public int climbStairs(int n) {
if (n <= 2) { // 递归终结点
return n;
}
return climbStairs(n - 1) + climbStairs(n - 2);
}
}
如果我们这时候计算的是 climbStairs(5)，通过下图可以看到我们一共计算 f(3) 2次、 f(2) 3次、 f(1) 2次。这是在台阶数 n 很小的情况下，如果 n 很大的话，重复计算的模块会变的更多。
数组记录中间结果
这个时候如果我们能够通过一个数组来记录中间结果就好了，当上图中的每一个节点如果已经计算过，就不再重复计算了。
代码如下：
class Solution {
public int climbStairs(int n) {
int[] dp = new int[n + 1];
return this.climbStairs(dp, n);
}
private int climbStairs(int[] dp, int n) {
if (n <= 1) {
return 1;
}
if (dp[n] > 0) {
return dp[n];
}
int num = climbStairs(dp, n - 1) + climbStairs(dp, n - 2);
dp[n] = num;
return num;
}
}
去掉递归
递归会新建很多局部变量，建立很多栈帧，带来很多不必要的消耗，如果能够去除递归效率会有进一步的提升。
上面我们都是从图中的根结点一步一步向下计算，是一个深度优先搜索的过程，如果我们从根节点向上算就能去掉递归了。
代码如下：
/**
* Created by jacob on 2019-08-20.
*/
public class Solution2 {
public int climbStairs(int n) {
int[] dp = new int[n + 1];
for (int i = 1; i <= n; i++) {
if (i <= 2) {
dp[i] = i;
} else {
dp[i] = dp[i - 1] + dp[i - 2];
}
}
return dp[n];
}
}
动态规划题目
多刷点题，就啥都明白了。
