题目：62.不同路径
1.二维dp数组dp[i][j]含义：到达（i，j）位置有dp[i][j]种方法。
2.动态转移方程：dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
3.初始化：dp[0][j] = 1, dp[i][0] = 1 （第一行第一列都为1）
4.遍历顺序：从上向下，从左往右
5.打印dp
二维数组怎么定义？
代码如下：
class Solution {
public:
int uniquePaths(int m, int n) {
vector<vector<int>> dp(m, vector<int>(n, 0));
for(int i = 0; i < m; i++){
dp[i][0] = 1;
}
for(int j = 0; j < n; j++){
dp[0][j] = 1;
}
for(int i = 1; i < m; i++){
for(int j = 1; j < n; j++){
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
};题目：63.不同路径||
思路：
1.dp数组及含义：到达（i，j）位置有dp[i][j]种方法。
2.状态转移方程：dp[i][j] = dp[i - 1][j] + dp[i][j - 1]（遇到空位置才进行计算）
3.初始化：dp[0][j] = 1, dp[i][0] = 1 （第一行第一列都为1）。当遇到障碍后停止。
4.遍历顺序：从上向下，从左往右
5.打印dp
代码如下：
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
vector<vector<int>> dp(obstacleGrid.size(), vector<int>(obstacleGrid[0].size(), 0));
for(int i = 0; i < obstacleGrid.size() && obstacleGrid[i][0] == 0; i++){
dp[i][0] = 1;
}
for(int j = 0; j < obstacleGrid[0].size() && obstacleGrid[0][j] == 0; j++){
dp[0][j] = 1;
}
for(int i = 1; i < obstacleGrid.size(); i++){
for(int j = 1; j <obstacleGrid[0].size(); j++){
if(obstacleGrid[i][j] == 0){
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
}
return dp[obstacleGrid.size() - 1][obstacleGrid[0].size() - 1];
}
};题目：343.整数拆分
关键在于理解递推公式。（考虑好有几个需要比较的情况）
什么时候乘积最大？拆成尽可能相等的数
思路：
1.dp含义：数i经过拆分后，得到最大的乘积dp[i]
2.状态转移方程（dp[i] 是依靠 dp[i - j]的状态）：
递推公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
1)有两种拆分方式：一是i * (i - j)直接相乘（把 i 拆成两个数）；
二是 j * dp[i - j]（把 i 拆成三个数及以上）
2)在递推公式推导的过程中，每次计算dp[i]，取最大的而已
因为在第二层循环中会不断得到新的dp[i]，用本轮for循环得到的dp[i]与之前得到的最大的dp[i]作比较，取更大的。
3.初始化：
拆分0和拆分1的最大乘积是多少？
这是无解的。
这里我只初始化dp[2] = 1，从dp[i]的定义来说，拆分数字2，得到的最大乘积是1，这个没有任何异议！确定遍历顺序，先来看看递归公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
4.确定遍历顺序：从前到后
确定遍历顺序，先来看看递归公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
dp[i] 是依靠 dp[i - j]的状态，所以遍历i一定是从前向后遍历，先有dp[i - j]再有dp[i]。
5.打印dp数组：
class Solution {
public:
int integerBreak(int n) {
vector<int> dp(n + 1);
dp[0] = 0;
dp[1] = 0;
dp[2] = 1;
for(int i = 3; i <= n; i++){
for(int j = 1; j <= i / 2; j++){
dp[i] = max(max(j * (i - j), j * dp[i - j]), dp[i]);
}
}
return dp[n];
}
};题目：96.不同的二叉搜索树
思路：
1.dp数组含义：含有 i 个节点的二叉搜索树共有dp[i]种
2.状态转移方程：
dp[3]，就是 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量
元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量
元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量
元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量
有2个元素的搜索树数量就是dp[2]。
有1个元素的搜索树数量就是dp[1]。
有0个元素的搜索树数量就是dp[0]。
所以dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]
所以递推公式：dp[i] += dp[j - 1] * dp[i - j]; ，j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量
3.初始化：
初始化，只需要初始化dp[0]就可以了，推导的基础，都是dp[0]。
那么dp[0]应该是多少呢？
从定义上来讲，空节点也是一棵二叉树，也是一棵二叉搜索树，这是可以说得通的。
从递归公式上来讲，dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] 中以j为头结点左子树节点数量为0，也需要dp[以j为头结点左子树节点数量] = 1， 否则乘法的结果就都变成0了。
4.遍历顺序：左往右
5.打印dp
容易犯得典型错误：
class Solution {
public:
int numTrees(int n) {
vector<int> dp(n + 1, 0);
dp[0] = 1; //易错：空二叉树也是二叉搜索树
dp[1] = 1;
dp[2] = 2;
for(int i = 3; i <= n; i++){ //统计以1，2,...,n为结点有多少种不同的二叉树
for(int j = 1; j <= i; j++){ //统计以1，2,...,i为头结点，同时共n个节点，有多少种不同的二叉树
dp[i] += dp[j - 1] * dp[i - j];
}
}
return dp[n];
}
};在初始化时赋值dp[2]等于0，如果题目中n = 1,则会越界。
这一点很容易犯错
其实经常会有一个困惑，到底初始化时要初始前多少个呢？（手动模拟一下）
正确代码如下：
class Solution {
public:
int integerBreak(int n) {
vector<int> dp(n + 1);
dp[0] = 0;
for(int i = 1; i <= n; i++){
for(int j = 1; j <= i / 2; j++){
dp[i] = max(max(j * (i - j), j * dp[i - j]), dp[i]);
}
}
return dp[n];
}
};其实只用定义dp[0] = 0，dp[1]往后都是可以动态规划循环推出来的。
