专题九：动态规划
声明：
参考：代码随想录
个人总结归纳，仅用于复习回顾，不作他用！如发现文章内容有误，恳请批评指出！
目录
动态规划理论基础
1、什么是动态规划
2、动态规划的解题步骤
3、动态规划应该如何debug
基础题目
例1： 509. 斐波那契数 - 力扣（LeetCode）
例2： 70. 爬楼梯 - 力扣（LeetCode）
例3：746. 使用最小花费爬楼梯 - 力扣（LeetCode）
例4：62. 不同路径 - 力扣（LeetCode）
例5： 63. 不同路径 II - 力扣（LeetCode）
例6：343. 整数拆分 - 力扣（LeetCode）
编辑
编辑 例7：96. 不同的二叉搜索树 - 力扣（LeetCode）
背包问题
题型一：01背包
01背包理论基础
例1：416. 分割等和子集 - 力扣（LeetCode）
例2：1049. 最后一块石头的重量 II - 力扣（LeetCode）
例3： 494. 目标和 - 力扣（LeetCode）
例4：474. 一和零 - 力扣（LeetCode）
编辑
题型二：完全背包
完全背包理论基础
例1：518. 零钱兑换 II - 力扣（LeetCode）
例2：377. 组合总和 Ⅳ - 力扣（LeetCode）
例3：70.爬楼梯（进阶版）力扣无原题
例4： 322. 零钱兑换 - 力扣（LeetCode）
例5：279. 完全平方数 - 力扣（LeetCode）
例6：139. 单词拆分 - 力扣（LeetCode）
题型三：多重背包
题型四：打家劫舍
例1：198. 打家劫舍 - 力扣（LeetCode）
例2：213. 打家劫舍 II - 力扣（LeetCode）
例3：337. 打家劫舍 III - 力扣（LeetCode）
题型五：股票问题
例1：121. 买卖股票的最佳时机 - 力扣（LeetCode）
例2：122. 买卖股票的最佳时机 II - 力扣（LeetCode）
例3：123. 买卖股票的最佳时机 III - 力扣（LeetCode）
例4：188. 买卖股票的最佳时机 IV - 力扣（LeetCode）
例5：309. 最佳买卖股票时机含冷冻期 - 力扣（LeetCode）
例6：714. 买卖股票的最佳时机含手续费 - 力扣（LeetCode）
题型六：子序列问题
分类一：子序列（不连续）问题
例1：300. 最长递增子序列 - 力扣（LeetCode）
例2：1143. 最长公共子序列 - 力扣（LeetCode）
例3：1035. 不相交的线 - 力扣（LeetCode）
分类二：子序列（连续）问题
例1：674. 最长连续递增序列 - 力扣（LeetCode）
例2： 718. 最长重复子数组 - 力扣（LeetCode）
例3：53. 最大子数组和 - 力扣（LeetCode）
分类三：编辑距离问题
例1： 392. 判断子序列 - 力扣（LeetCode）
例2：115. 不同的子序列 - 力扣（LeetCode）
例3：583. 两个字符串的删除操作 - 力扣（LeetCode）
例4：72. 编辑距离 - 力扣（LeetCode）
分类四：回文问题
例1：647. 回文子串 - 力扣（LeetCode）
例2：516. 最长回文子序列 - 力扣（LeetCode）
动态规划理论基础
1、什么是动态规划
动态规划，英文：Dynamic Programming，简称DP，如果某一问题有很多重叠子问题，使用动态规划是最有效的。
所以动态规划中每一个状态一定是由上一个状态推导出来的，这一点就区分于贪心，贪心没有状态推导，而是从局部直接选最优的，
2、动态规划的解题步骤
- 确定dp数组（dp table）以及下标的含义
- 确定递推公式
- dp数组如何初始化
- 确定遍历顺序
- 举例推导dp数组
3、动态规划应该如何debug
（1）做动规的题目，写代码之前一定要把状态转移在dp数组的上具体情况模拟一遍，心中有数，确定最后推出的是想要的结果。
（2）然后再写代码，如果代码没通过就打印dp数组，看看是不是和自己预先推导的哪里不一样。
（3）如果打印出来和自己预先模拟推导是一样的，那么就是自己的递归公式、初始化或者遍历顺序有问题了。
（4）如果和自己预先模拟推导的不一样，那么就是代码实现细节有问题。
基础题目
例1： 509. 斐波那契数 - 力扣（LeetCode）
class Solution {
public:
int fib(int n) {
if (n <= 1) return n;
int dp[2];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
int sum = dp[0] + dp[1];
dp[0] = dp[1];
dp[1] = sum;
}
return dp[1];
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(1)分析：
动规五部曲：
1、确定dp数组以及下标的含义
dp[i]的定义为：第i个数的斐波那契数值是dp[i]
2、 确定递归公式
状态转移方程 dp[i] = dp[i - 1] + dp[i - 2];
3、dp数组如何初始化
dp[0] = 0;
dp[1] = 1;
4、确定遍历顺序
从递归公式dp[i] = dp[i - 1] + dp[i - 2];中可以看出，dp[i]是依赖 dp[i - 1] 和 dp[i - 2]，那么遍历的顺序一定是从前到后遍历的
5、举例推导dp数组
按照这个递推公式dp[i] = dp[i - 1] + dp[i - 2]，我们来推导一下，当N为10的时候，dp数组应该是如下的数列：
0 1 1 2 3 5 8 13 21 34 55
如果代码写出来，发现结果不对，就把dp数组打印出来看看和我们推导的数列是不是一致的。
只需要维护两个数值就可以了，不需要记录整个序列。
例2： 70. 爬楼梯 - 力扣（LeetCode）
class Solution {
public:
int climbStairs(int n) {
if(n <= 1) return n;// 因为下面直接对dp[2]操作了，防止空指针
vector dp(n + 1);
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {// 注意i是从3开始的
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n) 优化空间复杂度：
class Solution {
public:
int climbStairs(int n) {
if(n <= 1) return n;
int dp[3];
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {
int sum = dp[1] + dp[2];
dp[1] = dp[2];
dp[2] = sum;
}
return dp[2];
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(1)分析：
动规五部曲：
1、确定dp数组以及下标的含义
dp[i]： 爬到第i层楼梯，有dp[i]种方法
2、确定递推公式
dp[i] = dp[i - 1] + dp[i - 2]
首先dp[i - 1]，上i-1层楼梯，有dp[i - 1]种方法，那么再一步跳一个台阶就是dp[i]。
其次dp[i - 2]，上i-2层楼梯，有dp[i - 2]种方法，那么再一步跳两个台阶就是dp[i]。
所以dp[i]就是 dp[i - 1]与dp[i - 2]之和！
3、dp数组如何初始化
不考虑dp[0]如何初始化，只初始化dp[1] = 1，dp[2] = 2，然后从i = 3开始递推，这样才符合dp[i]的定义。 因为题目中说了n是一个正整数，根本就没说n有为0的情况
4、确定遍历顺序
根据递推公式可以得出：从前向后遍历
5、举例推导dp数组
下标： 1 2 3 4 5
dp数组：1 2 3 5 8
与斐波那契数列极其相似，唯一区别就是：没有讨论dp[0]应该是什么，因为dp[0]在本题没有意义。
例3：746. 使用最小花费爬楼梯 - 力扣（LeetCode）
class Solution {
public:
int minCostClimbingStairs(vector& cost) {
vector dp(cost.size() + 1);
dp[0] = 0;
dp[1] = 0;
for (int i = 2; i <= cost.size(); i++) {
dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
}
return dp[cost.size()];
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n) 优化空间复杂度：
class Solution {
public:
int minCostClimbingStairs(vector& cost) {
int dp0 = 0;
int dp1 = 0;
for (int i = 2; i <= cost.size(); i++) {
int dpi = min(dp1 + cost[i - 1], dp0 + cost[i - 2]);
dp0 = dp1;
dp1 = dpi;
}
return dp1;
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(1) 分析：
动规五部曲：
1、确定dp数组以及下标的含义
dp[i]的定义：到达第i台阶所花费的最少体力为dp[i]。
2、确定递推公式
可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。
dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。
dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。
一定是选最小的，所以dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
3、dp数组如何初始化
题目描述中明确说了 “你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。” 也就是说 到达 第 0 个台阶是不花费的，但从 第0 个台阶 往上跳的话，需要花费 cost[0]。
所以初始化 dp[0] = 0，dp[1] = 0;
4、确定遍历顺序
模拟台阶，而且dp[i]由dp[i-1]dp[i-2]推出，所以是从前到后遍历cost数组
5、举例推导dp数组
例4：62. 不同路径 - 力扣（LeetCode）
解法一：动态规划
class Solution {
public:
int uniquePaths(int m, int n) {
vector> dp(m, vector(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];
}
};
//动态规划
//时间复杂度O(m×n)
//空间复杂度O(m×n) 分析：
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。
2、确定递推公式
dp[i][j]只能从上 dp[i - 1][j] 和左 dp[i][j - 1] 两个方向得到，所以dp[i][j] = dp[i - 1][j] + dp[i][j - 1]。
3、dp数组的初始化
dp[i][0]一定都是1，因为从(0, 0)的位置到(i, 0)的路径只有一条，dp[0][j]也同理 。
所以初始化代码为：
for (int i = 0; i < m; i++) dp[i][0] = 1;
for (int j = 0; j < n; j++) dp[0][j] = 1;4、确定遍历顺序
由于递推公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j]都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。
这样就可以保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值的。
5、举例推导dp数组
解法二：数论方法
class Solution {
public:
int uniquePaths(int m, int n) {
long long numerator = 1;//分子
int denominator = m - 1;//分母
int count = m - 1;
int t = m + n - 2;
while (count--) {
numerator *= (t--);
while (denominator != 0 && numerator % denominator == 0) {
numerator /= denominator;
denominator--;
}
}
return numerator;
}
};
//数论
//时间复杂度O(m)
//空间复杂度O(1)分析：
m行n列，无论怎么走，到终点都需要m + n - 2步。其中一定有m - 1步是向下走的，不用管什么时候向下走，那么问题就可以转化为，给定m + n - 2个不同的数，随便取m - 1个数，有几种取法的组合问题。
注意：求组合的时候，要防止两个int相乘溢出！ 所以不能把算式的分子都算出来，分母都算出来再做除法。 需要在计算分子的时候，不断除以分母。
例5： 63. 不同路径 II - 力扣（LeetCode）
class Solution {
public:
int uniquePathsWithObstacles(vector>& obstacleGrid) {
int m = obstacleGrid.size();
int n = obstacleGrid[0].size();
if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) return 0;
vector> dp(m, vector(n, 0));
for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (obstacleGrid[i][j] == 1) continue;
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
};
//动态规划
//时间复杂度O(m×n)
//空间复杂度O(m×n) 分析：
本题与例4：不同路径 唯一的区别是 多了障碍物
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。
2、确定递推公式
dp[i][j] = dp[i - 1][j] + dp[i][j - 1]。
因为有了障碍，(i, j)如果就是障碍的话应该就保持初始状态（初始状态为0）。
if (obstacleGrid[i][j] == 0) { // 当(i, j)没有障碍的时候，再推导dp[i][j]
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}3、dp数组如何初始化
如果(i, 0) 这条边有了障碍之后，障碍之后（包括障碍）都是走不到的位置了，所以障碍之后的dp[i][0]应该还是初始值0。 下标(0, j)的初始化情况同理。
vector> dp(m, vector(n, 0));
for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1; 注意代码里for循环的终止条件，一旦遇到obstacleGrid[i][0] == 1的情况就停止dp[i][0]的赋值1的操作，dp[0][j]同理
4、确定遍历顺序
从递归公式dp[i][j] = dp[i - 1][j] + dp[i][j - 1] 中可以看出，一定是从左到右一层一层遍历，这样保证推导dp[i][j]的时候，dp[i - 1][j] 和 dp[i][j - 1]一定是有数值
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
if (obstacleGrid[i][j] == 1) continue;
dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}5、举例推导dp数组
例6：343. 整数拆分 - 力扣（LeetCode）
class Solution {
public:
int integerBreak(int n) {
vector dp(n + 1);
dp[2] = 1;
for (int i = 3; i <= n; i++) {
for (int j = 1; j <= i / 2; j++) {
dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
}
}
return dp[n];
}
};
//动态规划
//时间复杂度O(n^2)
//空间复杂度O(n) 分析：
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[i]：分拆数字i，可以得到的最大乘积为dp[i]。
2、确定递归公式：
dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
j * (i - j) 是单纯的把整数拆分为两个数相乘，而j * dp[i - j]是拆分成两个以及两个以上的个数相乘。
3、dp初始化
严格从dp[i]的定义来说，dp[0] dp[1] 不应该初始化，也就是没有意义的数值。
只初始化dp[2] = 1即可
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]。
因为拆分一个数n 使之乘积最大，那么一定是拆分成m个近似相同的子数相乘才是最大的。
例如 6 拆成 3 * 3， 10 拆成 3 * 3 * 4。 100的话 也是拆成m个近似数组的子数 相乘才是最大的。
只不过我们不知道m究竟是多少而已，但可以明确的是m一定大于等于2，既然m大于等于2，也就是 最差也应该是拆成两个相同的 可能是最大值。
那么 j 只需要遍历到 n/2 就可以，后面就没有必要遍历了，一定不是最大值。
5、举例推导dp数组
例7：96. 不同的二叉搜索树 - 力扣（LeetCode）
class Solution {
public:
int numTrees(int n) {
vector dp(n + 1);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
dp[i] += dp[j - 1] * dp[i - j];
}
}
return dp[n];
}
};
//动态规划
//时间复杂度O(n^2)
//空间复杂度O(n) 分析：
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[i] ： 1到i为节点组成的二叉搜索树的个数为dp[i]。
或 i个不同元素节点组成的二叉搜索树的个数为dp[i] 。
2、确定递推公式
dp[i] += dp[j - 1] * dp[i - j];
j相当于是头结点的元素，从1遍历到i为止。
j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量。
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]
3、dp数组初始化
推导基础都是从0开始的，因此只初始化dp[0]即可。
从定义上来讲，空节点也是一棵二叉树，也是一棵二叉搜索树。
从递归公式上来讲，dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] 中以j为头结点左子树节点数量为0，也需要dp[以j为头结点左子树节点数量] = 1， 否则乘法的结果就都变成0了。
所以初始化dp[0] = 1。
4、确定遍历顺序
首先一定是遍历节点数，从递归公式：dp[i] += dp[j - 1] * dp[i - j]可以看出，节点数为i的状态是依靠 i之前节点数的状态。
那么遍历i里面每一个数作为头结点的状态，用j来遍历。
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
dp[i] += dp[j - 1] * dp[i - j];
}
}5、举例推导dp数组
背包问题
题型一：01背包
01背包理论基础
举例：背包最大重量为4，物品为：
问背包能背的物品最大价值是多少？
二维dp数组01背包
动规五部曲：
1、确定dp数组以及下标的含义
dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
2、确定递推公式
- 不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以背包内的价值依然和前面相同。)
- 放物品i：由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值
所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
3、dp数组初始化
dp[i][0]：背包容量j为0，无论是选取哪些物品，背包价值总和一定为0。
dp[0][j]：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。
当 j < weight[0] 时，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。
当 j >= weight[0] 时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。
由递推公式 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可知：
dp[i][j]是由左上方数值推导出来的，所以其他下标初始为什么数值都可以，因为都会被覆盖。
为方便起见，统一初始化为0
// 初始化 dp
vector> dp(weight.size(), vector(bagweight + 1, 0));
for (int j = weight[0]; j <= bagweight; j++) {
dp[0][j] = value[0];
} 4、确定遍历顺序
（1）先遍历物品，再遍历背包重量
// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品
for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
}
}（2）先遍历背包，再遍历物品
// weight数组的大小 就是物品个数
for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
for(int i = 1; i < weight.size(); i++) { // 遍历物品
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
}
}以上两种遍历顺序均可，
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 递归公式中可以看出dp[i][j]是靠dp[i-1][j]和dp[i - 1][j - weight[i]]推导出来的。
dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向（包括正上方向），虽然两个for循环遍历的次序不同，但是dp[i][j]所需要的数据就是左上角，根本不影响dp[i][j]公式的推导！
5、举例推导dp数组
测试代码：
void test_2_wei_bag_problem1() {
vector weight = {1, 3, 4};
vector value = {15, 20, 30};
int bagweight = 4;
// 二维数组
vector> dp(weight.size(), vector(bagweight + 1, 0));
// 初始化
for (int j = weight[0]; j <= bagweight; j++) {
dp[0][j] = value[0];
}
// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品
for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
if (j < weight[i]) dp[i][j] = dp[i - 1][j];
else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
}
}
cout << dp[weight.size() - 1][bagweight] << endl;
}
int main() {
test_2_wei_bag_problem1();
} 一维dp数组01背包问题（滚动数组）
动规五部曲：
1、 确定dp数组的定义
在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。
2、一维dp数组的递推公式
不放物品：取自己dp[j] 相当于 二维dp数组中的dp[i-1][j]
放物品： 取dp[j - weight[i]] + value[i]，表示 容量为 j - 物品i重量 的背包 加上 物品i的价值。
所以递推公式为：
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);3、一维dp数组初始化
dp[0]应该为0，因为背包容量为0所背的物品的最大价值就是0。
如果题目给的价值都是正整数，那么非0下标都初始化为0即可。
这样才能让dp数组在递归公式的过程中取的最大的价值，而不是被初始值覆盖了。
因此，dp数组均初始化为0。
4、一维dp数组遍历顺序
先遍历物品，再遍历背包容量
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}遍历背包顺序与二维dp数组不一样！！！
二维dp遍历的时候，背包容量是从小到大，而一维dp遍历的时候，背包是从大到小。
倒序遍历是为了保证物品i只被放入一次！。但如果一旦正序遍历了，那么物品0就会被重复加入多次！
为什么二维dp数组遍历的时候不用倒序呢？
因为对于二维dp，dp[i][j]都是通过上一层即dp[i - 1][j]计算而来，本层的dp[i][j]并不会被覆盖！
一维dp数组不可以先遍历背包容量再遍历物品！！！
因为一维dp的写法，背包容量一定是要倒序遍历，如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。
倒序遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。
5、举例推导dp数组
测试代码：
void test_1_wei_bag_problem() {
vector weight = {1, 3, 4};
vector value = {15, 20, 30};
int bagWeight = 4;
// 初始化
vector dp(bagWeight + 1, 0);
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}
cout << dp[bagWeight] << endl;
}
int main() {
test_1_wei_bag_problem();
} 例1：416. 分割等和子集 - 力扣（LeetCode）
class Solution {
public:
bool canPartition(vector& nums) {
int sum = 0;
// dp[i]中的i表示背包内总和
// 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
// 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
vector dp(10001, 0);
for (int i = 0; i < nums.size(); i++) {
sum += nums[i];
}
// 也可以使用库函数一步求和
// int sum = accumulate(nums.begin(), nums.end(), 0);
if (sum % 2 == 1) return false;
int target = sum / 2;
// 开始 01背包
for (int i = 0; i < nums.size(); i++) {
for (int j = target; j >= nums[i]; j--) {// 每一个元素一定是不可重复放入，所以从大到小遍历
dp[j] = max(dp[j], dp[j - nums[i]]+ nums[i]);
}
}
// 集合中的元素正好可以凑成总和target
if (dp[target] == target) return true;
return false;
}
};
//动态规划-01背包
//时间复杂度O(n^2)
//空间复杂度O(n)，虽然dp数组大小为一个常数，但是大常数 分析：
一个商品如果可以重复多次放入是完全背包，而只能放入一次是01背包，写法还是不一样的。
本题中要使用的是01背包，因为元素只能用一次。
- 背包的体积为sum / 2
- 背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值
- 背包如果正好装满，说明找到了总和为 sum / 2 的子集。
- 背包中每一个元素是不可重复放入。
动规五部曲：
1、 确定dp数组以及下标的含义
dp[j]表示 背包总容量（所能装的总重量）是j，放进物品后，背包的最大重量为dp[j]。
如果背包容量为target， dp[target]就是装满 背包之后的重量，所以 当 dp[target] == target 的时候，背包就装满了。
2、确定递推公式
01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
本题，相当于背包里放入数值，那么物品i的重量是nums[i]，其价值也是nums[i]。
所以递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
3、dp数组初始化
均初始化为0
// 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
// 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
vector dp(10001, 0); 4、 确定遍历顺序
使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
// 开始 01背包
for(int i = 0; i < nums.size(); i++) {
for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
}
}5、举例推导dp数组
dp[j]的数值一定是小于等于j的。
如果dp[j] == j 说明，集合中的子集总和正好可以凑成总和j。
例2：1049. 最后一块石头的重量 II - 力扣（LeetCode）
class Solution {
public:
int lastStoneWeightII(vector& stones) {
int sum = 0;
vector dp(15001, 0);
for (int i = 0; i < stones.size(); i++) sum += stones[i];
int target = sum / 2;
for (int i = 0; i < stones.size(); i++) {// 遍历物品
for (int j = target; j >= stones[i]; j--) {// 遍历背包
dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
}
}
return sum - dp[target] - dp[target];
}
};
//动态规划-01背包
//时间复杂度O(m×n)，m是石头总重量（准确的说是总重量的一半），n为石头块数
//空间复杂度O(m) 分析：
动规五部曲：
1、确定dp数组以及下标的含义
dp[j]表示容量为j的背包，最多可以背最大重量为dp[j]。本题中，石头的重量是 stones[i]，石头的价值也是 stones[i]
2、确定递归公式
01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
本题则是：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
3、dp数组初始化
因为提示中给出1 <= stones.length <= 30，1 <= stones[i] <= 1000，所以最大重量就是30 * 1000。target是最大重量的一半，所以dp数组开到15000大小就可以了。
因为重量都不会是负数，所以dp[j]都初始化为0即可，这样在递归公式dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);中dp[j]才不会初始值所覆盖。
4、确定遍历顺序
使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
for (int i = 0; i < stones.size(); i++) { // 遍历物品
for (int j = target; j >= stones[i]; j--) { // 遍历背包
dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
}
}5、举例推导dp数组
最后dp[target]里是容量为target的背包所能背的最大重量。
那么分成两堆石头，一堆石头的总重量是dp[target]，另一堆就是sum - dp[target]。
在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于dp[target]的。
那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。
例3： 494. 目标和 - 力扣（LeetCode）
class Solution {
public:
int findTargetSumWays(vector& nums, int target) {
int sum = 0;
for (int i = 0; i < nums.size(); i++) sum += nums[i];
if (abs(target) > sum) return 0;
if ((target + sum) % 2 == 1) return 0;
int bagSize = (target + sum) / 2;
vector dp(bagSize + 1, 0);
dp[0] = 1;
for (int i = 0; i < nums.size(); i++) {
for (int j = bagSize; j >= nums[i]; j--) {
dp[j] += dp[j - nums[i]];
}
}
return dp[bagSize];
}
};
//动态规划
//时间复杂度O(n×m)，n为正数个数，m为背包容量
//空间复杂度O(m) 分析：
如何将本题转化为01背包问题？
因为每个物品（题目中的1）只用一次！
这次和之前遇到的背包问题不一样了，之前都是求容量为j的背包，最多能装多少。
本题则是装满有几种方法。其实这就是一个组合问题了
假设加法的总和为x，那么减法对应的总和就是sum - x。
所以我们要求的是 x - (sum - x) = target
x = (target + sum) / 2
此时问题就转化为，装满容量为x的背包，有几种方法。
这里的x，就是bagSize，也就是我们后面要求的背包容量。
此时需要考虑两种特殊情况：
// 当(target + sum) / 2 除不开时，此时没有方案
if ((target + sum) % 2 == 1) return 0; // 当负数和大于正数时，此时没有方案
if (abs(target) > sum) return 0; 动规五部曲：
1、确定dp数组以及下标的含义
dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法
2、确定递推公式
dp[j] += dp[j - nums[i]]例如：dp[j]，j 为5，
- 已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 容量为5的背包。
- 已经有一个2（nums[i]） 的话，有 dp[3]种方法 凑成 容量为5的背包。
- 已经有一个3（nums[i]） 的话，有 dp[2]中方法 凑成 容量为5的背包
- 已经有一个4（nums[i]） 的话，有 dp[1]中方法 凑成 容量为5的背包
- 已经有一个5 （nums[i]）的话，有 dp[0]中方法 凑成 容量为5的背包
3、dp数组如何初始化
dp[0] = 1;
dp[0]是在公式中一切递推结果的起源，如果dp[0]是0的话，递推结果将都是0。
4、确定遍历顺序
nums放在外循环，target在内循环，且内循环倒序。
5、举例推导dp数组
输入：nums: [1, 1, 1, 1, 1], S: 3
bagSize = (S + sum) / 2 = (3 + 5) / 2 = 4
dp数组状态变化如下：
例4：474. 一和零 - 力扣（LeetCode）
class Solution {
public:
int findMaxForm(vector& strs, int m, int n) {
vector> dp(m + 1, vector (n + 1, 0));// 默认初始化0
for (string str : strs) {// 遍历物品
int oneNum = 0, zeroNum = 0;
for (char c : str) {
if (c == '0') zeroNum++;
else oneNum++;
}
for (int i = m; i >= zeroNum; i--) { // 遍历背包容量且从后向前遍历！
for (int j = n; j >= oneNum; j--) {
dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
}
}
}
return dp[m][n];
}
};
//动态规划
//时间复杂度O(kmn),k 为strs的长度
//空间复杂度O(mn) 分析：
本题中strs 数组里的元素就是物品，每个物品都是一个！
而m 和 n相当于是一个背包，两个维度的背包。
所以本题其实是01背包问题！
只不过这个背包有两个维度，一个是m 一个是n，而不同长度的字符串就是不同大小的待装物品。
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。
2、确定递推公式
dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。
dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。（+1就代表将字符串放入背包，物品数量+1）
然后我们在遍历的过程中，取dp[i][j]的最大值。
所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
对比01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]））。
这就是一个典型的01背包！ 只不过物品的重量有了两个维度而已。
3、dp数组初始化
01背包的dp数组初始化为0即可。
因为物品价值不会是负数，初始为0，保证递推的时候dp[i][j]不会被初始值覆盖。
4、确定遍历顺序
01背包外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历！
本题物品就是strs里的字符串，背包容量就是题目描述中的m和n。
遍历背包容量的两层for循环并没有先后顺序，都代表物品重量的维度，先遍历哪一个都行！
5、举例推导dp数组
题型二：完全背包
完全背包理论基础
有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。
完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。
01背包和完全背包在代码上唯一不同就是体现在遍历顺序上：
01背包内嵌的循环是从大到小遍历，为了保证每个物品仅被添加一次。
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}而完全背包的物品是可以添加多次的，所以要从小到大去遍历，即：
// 先遍历物品，再遍历背包
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = weight[i]; j <= bagWeight ; j++) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}dp状态图如下：
01背包中二维dp数组的两个for遍历的先后循序是可以颠倒了，一维dp数组的两个for循环先后循序一定是先遍历物品，再遍历背包容量。
在完全背包中，对于一维dp数组来说，其实两个for循环嵌套顺序是无所谓的！
因为dp[j] 是根据 下标j之前所对应的dp[j]计算出来的。 只要保证下标j之前的dp[j]都是经过计算的就可以了。
// 先遍历背包，再遍历物品
for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
for(int i = 0; i < weight.size(); i++) { // 遍历物品
if (j - weight[i] >= 0) dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
cout << endl;
}C++测试代码：
// 先遍历物品，在遍历背包
void test_CompletePack() {
vector weight = {1, 3, 4};
vector value = {15, 20, 30};
int bagWeight = 4;
vector dp(bagWeight + 1, 0);
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = weight[i]; j <= bagWeight; j++) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
}
cout << dp[bagWeight] << endl;
}
int main() {
test_CompletePack();
} 例1：518. 零钱兑换 II - 力扣（LeetCode）
class Solution {
public:
int change(int amount, vector& coins) {
vector dp(amount + 1, 0);
dp[0] = 1;
for (int i = 0; i < coins.size(); i++) {// 遍历物品
for (int j = coins[i]; j <= amount; j++) {// 遍历背包
dp[j] += dp[j - coins[i]];
}
}
return dp[amount];
}
};
//动态规划
//时间复杂度O(mn),其中 m 是amount，n 是 coins 的长度
//空间复杂度O(m) 分析：
本题要求解的是凑成总金额的硬币组合数！
动规五部曲：
1、 确定dp数组以及下标的含义
dp[j]：凑成总金额j的货币组合数为dp[j]
2、确定递推公式
dp[j] += dp[j - coins[i]];
3、dp数组如何初始化
dp[0] = 1; dp[0] = 1是 递归公式的基础。如果dp[0] = 0 的话，后面所有推导出来的值都是0了。
下标非0的dp[j]初始化为0，这样累计加dp[j - coins[i]]的时候才不会影响真正的dp[j]
4、确定遍历顺序
外层for循环遍历物品（钱币），内层for遍历背包（金钱总额）：
for (int i = 0; i < coins.size(); i++) { // 遍历物品
for (int j = coins[i]; j <= amount; j++) { // 遍历背包容量
dp[j] += dp[j - coins[i]];
}
}假设：coins[0] = 1，coins[1] = 5。
那么就是先把1加入计算，然后再把5加入计算，得到的方法数量只有{1, 5}这种情况。而不会出现{5, 1}的情况。
所以这种遍历顺序中dp[j]里计算的是组合数！
外层for循环遍历背包（金钱总额），内层for遍历物品（钱币）：
for (int j = 0; j <= amount; j++) { // 遍历背包容量
for (int i = 0; i < coins.size(); i++) { // 遍历物品
if (j - coins[i] >= 0) dp[j] += dp[j - coins[i]];
}
}背包容量的每一个值，都是经过 1 和 5 的计算，包含了{1, 5} 和 {5, 1}两种情况。
此时dp[j]里算出来的就是排列数！
5、举例推导dp数组
例2：377. 组合总和 Ⅳ - 力扣（LeetCode）
class Solution {
public:
int combinationSum4(vector& nums, int target) {
vector dp(target + 1, 0);
dp[0] = 1;
for (int i = 0; i <= target; i++) {// 遍历背包
for (int j = 0; j < nums.size(); j++) {// 遍历物品
if (i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {
dp[i] += dp[i - nums[j]];
}
}
}
return dp[target];
}
};
//动态规划
//时间复杂度O(mn)，m代表target，n代表nums的长度
//空间复杂度O(m) C++测试用例有两个数相加超过int的数据，所以需要在if里加上dp[i] < INT_MAX - dp[i - num]。
分析：
本题旨在求排列数！
动规五部曲：
1、确定dp数组以及下标的含义
dp[i]: 凑成目标正整数为 i 的排列个数为dp[i]
2、确定递推公式
dp[i] += dp[i - nums[j]];
3、dp数组如何初始化
dp[0] = 1; 非0下标的dp[i] = 0;
4、确定遍历顺序
target（背包）放在外循环，将nums（物品）放在内循环，内循环从前到后遍历。
5、举例推导dp数组
例3：70.爬楼梯（进阶版）力扣无原题
假设你正在爬楼梯，需要n阶才能到达楼顶。
每次你可以爬1~m个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定n是一个正整数。
class Solution {
public:
int climbStairs(int n) {
vector dp(n + 1, 0);
dp[0] = 1;
for (int i = 1; i <= n; i++) { // 遍历背包
for (int j = 1; j <= m; j++) { // 遍历物品
if (i - j >= 0) dp[i] += dp[i - j];
}
}
return dp[n];
}
};
//动态规划
//时间复杂度O(mn)，m表示最多可以爬m个台阶
//空间复杂度O(n) 分析：
本题是力扣原题70.爬楼梯的进阶题，将原来的每次只能爬1或2阶，改为每次可以爬1~m阶，问有多少种不同的方法可以爬到楼顶。
1阶，2阶，.... m阶就是物品，楼顶就是背包。
每一阶可以重复使用，例如跳了1阶，还可以继续跳1阶。
问跳到楼顶有几种方法其实就是问装满背包有几种方法。
此时本题就变成一个完全背包问题了！
动规五部曲：
1、确定dp数组以及下标的含义
dp[i]：爬到有i个台阶的楼顶，有dp[i]种方法。
2、确定递推公式
dp[i]有几种来源，dp[i - 1]，dp[i - 2]，dp[i - 3] 等等，即：dp[i - j]
那么递推公式为：dp[i] += dp[i - j]
3、dp数组如何初始化
dp[0] = 1; dp[0]是递归中一切数值的基础所在，如果dp[0]是0的话，其他数值都是0了。
下标非0的dp[i]初始化为0，因为dp[i]是靠dp[i-j]累计上来的，dp[i]本身为0这样才不会影响结果。
4、确定遍历顺序
背包里求排列问题，即：1、2 步 和 2、1 步都是上三个台阶，但是这两种方法不一样！
所以需将背包遍历放在外循环，将物品遍历放在内循环。
每一步可以走多次，这是完全背包，内循环需要从前向后遍历。
5、举例来推导dp数组
略
代码中把m改成2就是本题70.爬楼梯可以AC的代码了。
例4： 322. 零钱兑换 - 力扣（LeetCode）
class Solution {
public:
int coinChange(vector& coins, int amount) {
vector dp(amount + 1, INT_MAX);
dp[0] = 0;
for (int i = 0; i < coins.size(); i++) {//遍历物品
for (int j = coins[i]; j <= amount; j++) {//遍历背包
if (dp[j - coins[i]] != INT_MAX) { // 如果dp[j - coins[i]]是初始值则跳过
dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
}
}
}
if (dp[amount] == INT_MAX) return -1;
return dp[amount];
}
};
//动态规划
//时间复杂度O(amount*n)，n为coins的长度
//空间复杂度O(amount) 分析：
本题中硬币数量是无限的，这是典型的完全背包问题！
动规五部曲分析如下：
1、确定dp数组以及下标的含义
dp[j]：凑足总额为j所需钱币的最少个数为dp[j]
2、确定递推公式
凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]（考虑coins[i]）
所以dp[j] 要取所有 dp[j - coins[i]] + 1 中最小的。
递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
3、dp数组如何初始化
dp[0] = 0; 因为凑足总金额为0所需钱币的个数一定是0。
考虑到递推公式的特性，dp[j]必须初始化为一个最大的数，否则就会在min(dp[j - coins[i]] + 1, dp[j])比较的过程中被初始值覆盖。
所以下标非0的元素都是应该是最大值。
vector dp(amount + 1, INT_MAX);
dp[0] = 0; 4、确定遍历顺序
本题求钱币最小个数，那么钱币有顺序和没有顺序都可以，都不影响钱币的最小个数。
所以本题并不强调集合是组合还是排列。
所以本题的两个for循环的关系是：外层for循环遍历物品，内层for遍历背包或者外层for遍历背包，内层for循环遍历物品都是可以的！
5、举例推导dp数组
遍历方式：遍历背包放在外循环，遍历物品放在内循环也是可以的，代码如下：
class Solution {
public:
int coinChange(vector& coins, int amount) {
vector dp(amount + 1, INT_MAX);
dp[0] = 0;
for (int i = 1; i <= amount; i++) { // 遍历背包
for (int j = 0; j < coins.size(); j++) { // 遍历物品
if (i - coins[j] >= 0 && dp[i - coins[j]] != INT_MAX ) {
dp[i] = min(dp[i - coins[j]] + 1, dp[i]);
}
}
}
if (dp[amount] == INT_MAX) return -1;
return dp[amount];
}
}; 例5：279. 完全平方数 - 力扣（LeetCode）
class Solution {
public:
int numSquares(int n) {
vector dp(n + 1, INT_MAX);
dp[0] = 0;
for (int i = 0; i <= n; i++) {// 遍历背包
for (int j = 1; j * j <= i; j++) {// 遍历物品
dp[i] = min(dp[i - j * j] + 1, dp[i]);
}
}
return dp[n];
}
};
//动态规划
//时间复杂度O(n * √n)
//空间复杂度: O(n) 分析：
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[j]：和为j的完全平方数的最少数量为dp[j]
2、确定递推公式
dp[j] 可以由dp[j - i * i]推出， dp[j - i * i] + 1 便可以凑成dp[j]。
此时我们要选择最小的dp[j]，所以递推公式：dp[j] = min(dp[j - i * i] + 1, dp[j]);
3、dp数组如何初始化
dp[0] = 0; 和为0的完全平方数的最小数量一定是0
从递归公式dp[j] = min(dp[j - i * i] + 1, dp[j]);中可以看出每次dp[j]都要选最小的，所以非0下标的dp[j]一定要初始为最大值，这样dp[j]在递推的时候才不会被初始值覆盖。
4、确定遍历顺序
本题求最小数，因此怎样遍历都是可以的。
5、举例推导dp数组
class Solution {
public:
int numSquares(int n) {
vector dp(n + 1, INT_MAX);
dp[0] = 0;
for (int i = 1; i * i <= n; i++) { // 遍历物品
for (int j = i * i; j <= n; j++) { // 遍历背包
dp[j] = min(dp[j - i * i] + 1, dp[j]);
}
}
return dp[n];
}
}; 例6：139. 单词拆分 - 力扣（LeetCode）
class Solution {
public:
bool wordBreak(string s, vector& wordDict) {
unordered_set wordSet(wordDict.begin(), wordDict.end());
vector dp(s.size() + 1, false);
dp[0] = true;
for (int i = 1; i <= s.size(); i++) {// 遍历背包
for (int j = 0; j < i; j++) {// 遍历物品
string word = s.substr(j, i - j);//substr(起始位置，截取的个数)
if (wordSet.find(word) != wordSet.end() && dp[j]) {
dp[i] = true;
}
}
}
return dp[s.size()];
}
};
//动态规划
//时间复杂度O(n^3)，因为substr返回子串的副本是O(n)的复杂度（这里的n是substring的长度）
//空间复杂度O(n) 分析：
动规五部曲：
单词就是物品，字符串s就是背包，单词能否组成字符串s，就是问物品能不能把背包装满。
拆分时可以重复使用字典中的单词，说明就是一个完全背包！
动规五部曲分析如下：
1、确定dp数组以及下标的含义
dp[i] : 字符串长度为i的话，dp[i]为true，表示可以拆分为一个或多个在字典中出现的单词。
2、确定递推公式
如果确定dp[j] 是true，且 [j, i] 这个区间的子串出现在字典里，那么dp[i]一定是true（j < i ）。
所以递推公式是 if([j, i] 这个区间的子串出现在字典里 && dp[j]是true) 那么 dp[i] = true。
3、dp数组如何初始化
从递推公式中可以看出，dp[i] 的状态依靠 dp[j]是否为true，那么dp[0]就是递推的根基，dp[0]一定要为true，否则递推下去后面都都是false了。
下标非0的dp[i]初始化为false，只要没有被覆盖说明都是不可拆分为一个或多个在字典中出现的单词。
4、确定遍历顺序
本题求排列数，举例来说，s = "applepenapple", wordDict = ["apple", "pen"]
"apple", "pen" 是物品，那么我们要求 物品的组合一定是 "apple" + "pen" + "apple" 才能组成 "applepenapple"。
"apple" + "apple" + "pen" 或者 "pen" + "apple" + "apple" 是不可以的，那么我们就是强调物品之间顺序。
所以说，本题一定是 先遍历 背包，再遍历 物品。
5、举例推导dp[i]
dp[s.size()]就是最终结果。
题型三：多重背包
有N种物品和一个容量为V 的背包。第i种物品最多有Mi件可用，每件耗费的空间是Ci ，价值是Wi 。求解将哪些物品装入背包可使这些物品的耗费的空间 总和不超过背包容量，且价值总和最大。
多重背包是一种01背包！
转换方式一：每件物品最多有Mi件可用，把Mi件摊开，每个物品只用一次，转化为01背包问题。
举例：背包最大重量为10，物品重量和数量如表格所示，问背包能背的物品最大价值是多少？
上述问题可转化为如下形式：
void test_multi_pack() {
vector weight = {1, 3, 4};
vector value = {15, 20, 30};
vector nums = {2, 3, 2};
int bagWeight = 10;
for (int i = 0; i < nums.size(); i++) {
while (nums[i] > 1) { // nums[i]保留到1，把其他物品都展开
weight.push_back(weight[i]);
value.push_back(value[i]);
nums[i]--;
}
}
vector dp(bagWeight + 1, 0);
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
}
for (int j = 0; j <= bagWeight; j++) {
cout << dp[j] << " ";
}
cout << endl;
}
cout << dp[bagWeight] << endl;
}
int main() {
test_multi_pack();
}
//时间复杂度：O(m × n × k)，m：物品种类个数，n背包容量，k单类物品数量 转化方式二：把每种商品遍历的个数放在01背包里面在遍历一遍
void test_multi_pack() {
vector weight = {1, 3, 4};
vector value = {15, 20, 30};
vector nums = {2, 3, 2};
int bagWeight = 10;
vector dp(bagWeight + 1, 0);
for(int i = 0; i < weight.size(); i++) { // 遍历物品
for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
// 以上为01背包，然后加一个遍历个数
for (int k = 1; k <= nums[i] && (j - k * weight[i]) >= 0; k++) { // 遍历个数
dp[j] = max(dp[j], dp[j - k * weight[i]] + k * value[i]);
}
}
// 打印一下dp数组
for (int j = 0; j <= bagWeight; j++) {
cout << dp[j] << " ";
}
cout << endl;
}
cout << dp[bagWeight] << endl;
}
int main() {
test_multi_pack();
}
//时间复杂度：O(m × n × k)，m：物品种类个数，n背包容量，k单类物品数量 力扣上没有对应多重背包的习题，面试不会考，了解即可。
题型四：打家劫舍
例1：198. 打家劫舍 - 力扣（LeetCode）
class Solution {
public:
int rob(vector& nums) {
if (nums.size() == 0) return 0;
if (nums.size() == 1) return nums[0];
vector dp(nums.size());
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
for (int i = 2; i < nums.size(); i++) {
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
}
return dp[nums.size() - 1];
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n) 分析：
当前房屋偷与不偷取决于 前一个房屋和前两个房屋是否被偷了。
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。
2、确定递推公式
决定dp[i]的因素就是第i房间偷还是不偷。
如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出 下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。
如果不偷第i房间，那么dp[i] = dp[i - 1]，即考 虑i-1房，（注意这里是考虑，并不是一定要偷i-1房，这是容易混淆的点）
然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
3、dp数组如何初始化
从递推公式dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);可以看出，递推公式的基础就是dp[0] 和 dp[1]
从dp[i]的定义上来讲，dp[0] 一定是 nums[0]，dp[1]就是nums[0]和nums[1]的最大值即：dp[1] = max(nums[0], nums[1]);
4、确定遍历顺序
dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前到后遍历！
5、举例推导dp数组
红框dp[nums.size() - 1]为结果。
例2：213. 打家劫舍 II - 力扣（LeetCode）
// 注意注释中的情况二情况三，以及把198.打家劫舍的代码抽离出来了
class Solution {
private:
// 198.打家劫舍的逻辑
int robRange(vector& nums, int start, int end) {
if (end == start) return nums[start];
vector dp(nums.size());
dp[start] = nums[start];
dp[start + 1] = max(nums[start], nums[start + 1]);
for (int i = start + 2; i <= end; i++) {
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
}
return dp[end];
}
public:
int rob(vector& nums) {
if (nums.size() == 0) return 0;
if (nums.size() == 1) return nums[0];
int result1 = robRange(nums, 0, nums.size() - 2);// 情况二
int result2 = robRange(nums, 1, nums.size() - 1);// 情况三
return max(result1, result2);
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n) 分析：
这道题目和 例1：198打家劫舍 是差不多的，唯一区别就是成环了。
对于一个数组，成环的话主要有如下三种情况：
- 情况一：考虑不包含首尾元素
- 情况二：考虑包含首元素，不包含尾元素
- 情况三：考虑包含尾元素，不包含首元素
注意这里用的是"考虑"，例如情况三，虽然是考虑包含尾元素，但不一定要选尾部元素！ 对于情况三，取nums[1] 和 nums[3]就是最大的。
而情况二 和 情况三 都包含了情况一了，所以只考虑情况二和情况三就可以了。
本题分析到这里，剩下的逻辑就和 例1：198打家劫舍 一样了。
例3：337. 打家劫舍 III - 力扣（LeetCode）
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
private:
// 长度为2的数组，0：不偷，1：偷
vector robTree(TreeNode* cur) {
if (cur == nullptr) return vector{0, 0};
vector left = robTree(cur->left);
vector right = robTree(cur->right);
// 偷cur，那么就不能偷左右节点。
int val1 = cur->val + left[0] + right[0];
// 不偷cur，那么可以偷也可以不偷左右节点，则取较大的情况
int val2 = max(left[0], left[1]) + max(right[0], right[1]);
return {val2, val1};
}
public:
int rob(TreeNode* root) {
vector result = robTree(root);
return max(result[0], result[1]);
}
};
//动态规划
//时间复杂度O(n)，每个节点只遍历了一次
//空间复杂度O(logn)，算上递推系统栈的空间 分析：
本题是树形dp的入门题目，使用动态规划方法解决，就是使用状态转移容器来记录状态的变化，这里可以使用一个长度为2的数组，记录当前节点偷与不偷所得到的的最大金钱。
递归三部曲+动规五部曲：
1、确定递归函数的参数和返回值
这里我们要求一个节点 偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组。
参数为当前节点，代码如下：
vector robTree(TreeNode* cur) {
其实这里的返回数组就是dp数组。
所以dp数组（dp table）以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。
所以本题dp数组就是一个长度为2的数组！
长度为2的数组怎么标记树中每个节点的状态呢？
别忘了在递归的过程中，系统栈会保存每一层递归的参数。
2、确定终止条件
在遍历的过程中，如果遇到空节点的话，无论偷还是不偷都是0，所以就返回
if (cur == NULL) return vector{0, 0};
这也相当于dp数组的初始化
3、确定遍历顺序
首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。
通过递归左节点，得到左节点偷与不偷的金钱。
通过递归右节点，得到右节点偷与不偷的金钱。
代码如下：
// 下标0：不偷，下标1：偷
vector left = robTree(cur->left); // 左
vector right = robTree(cur->right); // 右
// 中
4、确定单层递归的逻辑
如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0];
如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的，所以：val2 = max(left[0], left[1]) + max(right[0], right[1]);
最后当前节点的状态就是{val2, val1}; 即：{不偷当前节点得到的最大金钱，偷当前节点得到的最大金钱}
代码如下：
vector left = robTree(cur->left); // 左
vector right = robTree(cur->right); // 右
// 偷cur
int val1 = cur->val + left[0] + right[0];
// 不偷cur
int val2 = max(left[0], left[1]) + max(right[0], right[1]);
return {val2, val1}; 5、举例推导dp数组
最后头结点就是 取下标0 和 下标1的最大值就是偷得的最大金钱。
题型五：股票问题
例1：121. 买卖股票的最佳时机 - 力扣（LeetCode）
class Solution {
public:
int maxProfit(vector& prices) {
int len = prices.size();
if (len == 0) return 0;
vector> dp(len, vector(2));
dp[0][0] -= prices[0];
dp[0][1] = 0;
for (int i = 1; i < len; i++) {
dp[i][0] = max(dp[i - 1][0], -prices[i]);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
}
return dp[len - 1][1];
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n) 分析：
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[i][0] 表示第i天持有股票所得最多现金 ，一开始现金是0，那么加入第i天买入股票现金就是 -prices[i]， 这是一个负数。
dp[i][1] 表示第i天不持有股票所得最多现金
注意这里说的是“持有”，“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态
2、确定递推公式
如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来
- 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
- 第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i]
那么dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);
如果第i天不持有股票即dp[i][1]， 也可以由两个状态推出来
- 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
- 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0]
同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
3、dp数组如何初始化
由递推公式 dp[i][0] = max(dp[i - 1][0], -prices[i]); 和 dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);可以看出：其基础都是要从dp[0][0]和dp[0][1]推导出来。
那么dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] -= prices[0];
dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;
4、确定遍历顺序
从递推公式可以看出dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。
5、举例推导dp数组
dp[5][1]就是最终结果。
为什么不是dp[5][0]呢？
因为本题中不持有股票状态所得金钱一定比持有股票状态得到的多！
优化：
从递推公式可以看出，dp[i]只是依赖于dp[i - 1]的状态。
dp[i][0] = max(dp[i - 1][0], -prices[i]);
dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
因此，只需要记录 当前天的dp状态和前一天的dp状态就可以了，可以使用滚动数组来节省空间，代码如下：
// 版本二
class Solution {
public:
int maxProfit(vector& prices) {
int len = prices.size();
vector> dp(2, vector(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
dp[0][0] -= prices[0];
dp[0][1] = 0;
for (int i = 1; i < len; i++) {
dp[i % 2][0] = max(dp[(i - 1) % 2][0], -prices[i]);
dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
}
return dp[(len - 1) % 2][1];
}
};
//时间复杂度：O(n)
//空间复杂度：O(1)
例2：122. 买卖股票的最佳时机 II - 力扣（LeetCode）
class Solution {
public:
int maxProfit(vector& prices) {
int len = prices.size();
if (len == 0) return 0;
vector> dp(len, vector(2, 0));
dp[0][0] -= prices[0];
dp[0][1] = 0;
for (int i = 1; i < len; i++) {
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);// 注意这里是和121. 买卖股票的最佳时机唯一不同的地方。
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
}
return dp[len - 1][1];
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n) 分析：
本题与 例1：121. 买卖股票的最佳时机 - 力扣（LeetCode）唯一不同的地方是：同一只股票可以买卖多次。
在代码上体现在递推公式不同：
如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来
- 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
- 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]
注意这里和 例1：121. 买卖股票的最佳时机 - 力扣（LeetCode） 唯一不同的地方，就是推导dp[i][0]的时候，第i天买入股票的情况。
在 例1：121. 买卖股票的最佳时机 - 力扣（LeetCode） 中，因为股票全程只能买卖一次，所以如果买入股票，那么第i天持有股票即dp[i][0]一定就是 -prices[i]。
而本题，因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。
那么第i天持有股票即dp[i][0]，如果是第i天买入股票，所得现金就是昨天不持有股票的所得现金 减去 今天的股票价格 即：dp[i - 1][1] - prices[i]。
优化： 滚动数组版本
// 版本二
class Solution {
public:
int maxProfit(vector& prices) {
int len = prices.size();
vector> dp(2, vector(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
dp[0][0] -= prices[0];
dp[0][1] = 0;
for (int i = 1; i < len; i++) {
dp[i % 2][0] = max(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1] - prices[i]);
dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
}
return dp[(len - 1) % 2][1];
}
};
//时间复杂度O(n)
//空间复杂度O(1) 例3：123. 买卖股票的最佳时机 III - 力扣（LeetCode）
class Solution {
public:
int maxProfit(vector& prices) {
int len = prices.size();
if (len == 0) return 0;
vector> dp(len, vector(5, 0));
dp[0][1] -= prices[0];
dp[0][3] -= prices[0];
for (int i = 1; i < len; i++) {
dp[i][0] = dp[i - 1][0];
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
}
return dp[len - 1][4];
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n×5) 分析：
本题与 例1：121. 买卖股票的最佳时机 - 力扣（LeetCode）和 例2：122. 买卖股票的最佳时机 II - 力扣（LeetCode） 相比，关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。
动态规划五部曲详细分析：
1、确定dp数组以及下标的含义
一天一共就有五个状态，
- 没有操作 （其实我们也可以不设置这个状态）
- 第一次持有股票
- 第一次不持有股票
- 第二次持有股票
- 第二次不持有股票
dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。
需要注意：dp[i][1]，表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票。
例如 dp[i][1] ，并不是说 第i天一定买入股票，有可能 第 i-1天 就买入了，那么 dp[i][1] 延续买入股票的这个状态。
2、确定递推公式
达到dp[i][1]状态，有两个具体操作：
- 操作一：第i天买入股票了，那么dp[i][1] = dp[i-1][0] - prices[i]
- 操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]
那么dp[i][1]究竟选 dp[i-1][0] - prices[i]，还是dp[i - 1][1]呢？
一定是选最大的，所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);
同理dp[i][2]也有两个操作：
- 操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
- 操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]
所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
同理可推出剩下状态部分：
dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
3、dp数组如何初始化
第0天没有操作，这个最容易想到，就是0，即：dp[0][0] = 0;
第0天做第一次买入的操作，dp[0][1] = -prices[0];
第0天做第一次卖出的操作，可以理解当天买入，当天卖出，所以dp[0][2] = 0;
第0天第二次买入操作，第二次买入依赖于第一次卖出的状态，其实相当于第0天第一次买入了，第一次卖出了，然后再买入一次（第二次买入），那么现在手头上没有现金，只要买入，现金就做相应的减少。
所以第二次买入操作，初始化为：dp[0][3] = -prices[0];
同理第二次卖出初始化dp[0][4] = 0;
4、确定遍历顺序
从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。
5、举例推导dp数组
红色框为最后两次卖出的状态。
现在最大的时候一定是卖出的状态，而两次卖出的状态现金最大一定是最后一次卖出。（也可以理解为：如果第一次卖出已经是最大值了，那么我们可以在当天立刻买入再立刻卖出。所以dp[4][4]已经包含了dp[4][2]的情况。）也就是说第二次卖出手里所剩的钱一定是最多的。
所以最终最大利润是dp[4][4]。
例4：188. 买卖股票的最佳时机 IV - 力扣（LeetCode）
class Solution {
public:
int maxProfit(int k, vector& prices) {
int len = prices.size();
if (len == 0) return 0;
vector> dp(len, vector(2 * k + 1, 0));
for (int j = 1; j < 2 * k; j += 2) {
dp[0][j] = -prices[0];
}
for (int i = 1; i < len; i++) {
for (int j = 0; j < 2 * k - 1; j += 2) {
dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
}
}
return dp[len - 1][2 * k];
}
};
//动态规划
//时间复杂度O(n * k)，其中 n 为 prices 的长度
//空间复杂度O(n * k) 分析：
本题与 例3：123. 买卖股票的最佳时机 III - 力扣（LeetCode）的差别是：至多有k次交易。
动规五部曲：
1、确定dp数组以及下标的含义
二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]
j的状态表示为：
- 0 表示不操作
- 1 第一次买入
- 2 第一次卖出
- 3 第二次买入
- 4 第二次卖出
- .....
规律：除了0以外，偶数就是卖出，奇数就是买入。
题目要求是至多有K笔交易，那么j的范围就定义为 2 * k + 1 就可以了。
所以二维dp数组的C++定义为：
vector> dp(prices.size(), vector(2 * k + 1, 0));
2、确定递推公式
强调：dp[i][1]，表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票，有可能是延续dp[i - 1][1]的持有状态。
达到dp[i][1]状态，有两个具体操作：
- 操作一：第i天买入股票了，那么dp[i][1] = dp[i - 1][0] - prices[i]
- 操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]
选最大的，所以 dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);
同理dp[i][2]也有两个操作：
- 操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
- 操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]
所以dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
同理可以类比剩下的状态，代码如下：
for (int j = 0; j < 2 * k - 1; j += 2) {
dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
}
本题和 例3：123. 买卖股票的最佳时机 III - 力扣（LeetCode）最大的区别就是这里要类比j为奇数是买，偶数是卖的状态。
3、dp数组如何初始化
第0天没有操作，就是0，即：dp[0][0] = 0;
第0天做第一次买入的操作，dp[0][1] = -prices[0];
第0天做第一次卖出的操作，可以理解当天买入，当天卖出，所以dp[0][2] = 0;
第0天第二次买入操作，第二次买入依赖于第一次卖出的状态，其实相当于第0天第一次买入了，第一次卖出了，然后在买入一次（第二次买入），那么现在手头上没有现金，只要买入，现金就做相应的减少。
所以第二次买入操作，初始化为：dp[0][3] = -prices[0];
第二次卖出初始化dp[0][4] = 0;
所以同理可以推出dp[0][j]当j为奇数的时候都初始化为 -prices[0]
代码如下：
for (int j = 1; j < 2 * k; j += 2) {
dp[0][j] = -prices[0];
}
在初始化的地方同样要类比j为偶数是卖、奇数是买的状态。
4、确定遍历顺序
从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。
5、举例推导dp数组
最后一次卖出，一定是利润最大的，dp[prices.size() - 1][2 * k]即红色部分就是最后求解。
例5：309. 最佳买卖股票时机含冷冻期 - 力扣（LeetCode）
class Solution {
public:
int maxProfit(vector& prices) {
int len = prices.size();
if (len == 0) return 0;
vector> dp(len, vector(4, 0));
dp[0][0] = -prices[0];
for (int i = 1; i < len; i++) {
dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][1] - prices[i], dp[i - 1][3] - prices[i]));
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
dp[i][2] = dp[i - 1][0] + prices[i];
dp[i][3] = dp[i - 1][2];
}
return max(dp[len - 1][3], max(dp[len - 1][1], dp[len - 1][2]));
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n) 分析：
本题与例2：122. 买卖股票的最佳时机 II - 力扣（LeetCode） 相比，多了一个冷冻期。
动规五部曲：
1、确定dp数组以及下标的含义
dp[i][j]，第i天状态为j，所剩的最多现金为dp[i][j]。
具体可以区分出如下四个状态：
- 状态一（j = 0）：持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作，一直持有）
- 不持有股票状态，这里就有两种卖出股票状态
- 状态二（j = 1）：保持卖出股票的状态（两天前就卖出了股票，度过一天冷冻期。或者是前一天就是卖出股票状态，一直没操作）
- 状态三（j = 2）：今天卖出股票
- 状态四（j = 3）：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！
注意这里的每一个状态，例如状态一，是持有股票股票状态并不是说今天一定就买入股票，而是说保持买入股票的状态即：可能是前几天买入的，之后一直没操作，所以保持买入股票的状态。
2、确定递推公式
达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：
- 操作一：前一天就是持有股票状态（状态一），dp[i][0] = dp[i - 1][0]
- 操作二：今天买入了，有两种情况
- 前一天是冷冻期（状态四），dp[i - 1][3] - prices[i]
- 前一天是保持卖出股票的状态（状态二），dp[i - 1][1] - prices[i]
那么dp[i][0] = max(dp[i - 1][0], dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]);
达到保持卖出股票状态（状态二）即：dp[i][1]，有两个具体操作：
- 操作一：前一天就是状态二
- 操作二：前一天是冷冻期（状态四）
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
达到今天就卖出股票状态（状态三），即：dp[i][2] ，只有一个操作：
昨天一定是持有股票状态（状态一），今天卖出
即：dp[i][2] = dp[i - 1][0] + prices[i];
达到冷冻期状态（状态四），即：dp[i][3]，只有一个操作：
昨天卖出了股票（状态三）
dp[i][3] = dp[i - 1][2];
综上分析，递推代码如下：
dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3], dp[i - 1][1]) - prices[i]);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
dp[i][2] = dp[i - 1][0] + prices[i];
dp[i][3] = dp[i - 1][2];
3、dp数组如何初始化
这里主要讨论一下第0天如何初始化。
如果是持有股票状态（状态一）那么：dp[0][0] = -prices[0]，一定是当天买入股票。
保持卖出股票状态（状态二），这里其实从 「状态二」的定义来说 ，很难明确应该初始多少，这种情况我们就看递推公式需要我们给他初始成什么数值。
如果i为1，第1天买入股票，那么递归公式中需要计算 dp[i - 1][1] - prices[i] ，即 dp[0][1] - prices[1]，那么dp[0][1] （即第0天的状态二）只能初始为0。如果初始为其他数值，那么第1天买入股票后 手里还剩的现金数量就不对了。
今天卖出了股票（状态三），同上分析，dp[0][2]初始化为0，dp[0][3]也初始为0。
4、确定遍历顺序
从递归公式上可以看出，dp[i] 依赖于 dp[i-1]，所以是从前向后遍历。
5、举例推导dp数组
最后结果是取 状态二，状态三，和状态四的最大值，状态四是冷冻期，最后一天如果是冷冻期也可能是最大值。
例6：714. 买卖股票的最佳时机含手续费 - 力扣（LeetCode）
class Solution {
public:
int maxProfit(vector& prices, int fee) {
int len = prices.size();
if (len == 0) return 0;
vector> dp(len, vector(2, 0));
dp[0][0] -= prices[0];
for (int i = 1; i < len; i++) {
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
}
return max(dp[len - 1][0], dp[len - 1][1]);
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n) 分析：
本题相对于例2：122. 买卖股票的最佳时机 II - 力扣（LeetCode），差别在于：计算卖出操作的时候减去手续费。
dp[i][0] 表示第i天持有股票所得最多现金。 dp[i][1] 表示第i天不持有股票所得最多现金
如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来：
- 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
- 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]
所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来：
- 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
- 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，注意这里需要有手续费了即：dp[i - 1][0] + prices[i] - fee
所以：dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
题型六：子序列问题
分类一：子序列（不连续）问题
例1：300. 最长递增子序列 - 力扣（LeetCode）
class Solution {
public:
int lengthOfLIS(vector& nums) {
if (nums.size() <= 1) return nums.size();
vector dp(nums.size(), 1);
int result = 0;
for (int i = 1; i < nums.size(); i++) {
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
}
if (dp[i] > result) result = dp[i];//取长的子序列
}
return result;
}
};
//动态规划
//时间复杂度O(n^2)
//空间复杂度O(n) 分析：
动规五部曲：
1、dp[i]的定义
dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度
为什么一定表示 “以nums[i]结尾的最长递增子序” ，因为我们在 做 递增比较的时候，如果比较 nums[j] 和 nums[i] 的大小，那么两个递增子序列一定分别以nums[j]为结尾 和 nums[i]为结尾， 要不然这个比较就没有意义了，不是尾部元素的比较那么 如何算递增呢。
2、状态转移方程
位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。
所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
注意这里不是要dp[i] 与 dp[j] + 1进行比较，而是要取dp[j] + 1的最大值。
3、dp[i]的初始化
每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1.
4、确定遍历顺序
dp[i] 是由 0 到 i-1 各个位置的最长递增子序列 推导而来，那么遍历i一定是从前向后遍历。
j 其实就是遍历 0 到 i-1，那么是从前到后，还是从后到前遍历都无所谓，只要把 0 到 i-1 的元素都遍历了就行了。 所以默认习惯 从前向后遍历。
遍历 i 的循环在外层，遍历 j 则在内层，代码如下：
for (int i = 1; i < nums.size(); i++) {
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
}
if (dp[i] > result) result = dp[i]; // 取长的子序列
}
5、举例推导dp数组
例2：1143. 最长公共子序列 - 力扣（LeetCode）
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
vector> dp(text1.size() + 1, vector(text2.size() + 1, 0));
for (int i = 1; i <= text1.size(); i++) {
for (int j = 1; j <= text2.size(); j++) {
if (text2[j - 1] == text1[i - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
return dp[text1.size()][text2.size()];
}
};
//动态规划
//时间复杂度O(n * m)，其中 n 和 m 分别为 text1 和 text2 的长度
//空间复杂度O(n * m) 分析：
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]
2、确定递推公式
如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。
即：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
代码如下：
if (text1[i - 1] == text2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
3、dp数组如何初始化
text1[0, i-1]和空串的最长公共子序列自然是0，所以dp[i][0] = 0;
同理dp[0][j]也是0。
其他下标都是随着递推公式逐步覆盖，初始为多少都可以，那么就统一初始为0。
代码：
vector> dp(text1.size() + 1, vector(text2.size() + 1, 0));
4、确定遍历顺序
从递推公式，可以看出，有三个方向可以推出dp[i][j]，如图：
那么为了在递推的过程中，这三个方向都是经过计算的数值，所以要从前向后，从上到下来遍历这个矩阵。
5、举例推导dp数组
最后红框dp[text1.size()][text2.size()]为最终结果。
例3：1035. 不相交的线 - 力扣（LeetCode）
class Solution {
public:
int maxUncrossedLines(vector& nums1, vector& nums2) {
vector> dp(nums1.size() + 1, vector(nums2.size() + 1, 0));
for (int i = 1; i <= nums1.size(); i++) {
for (int j = 1; j <= nums2.size(); j++) {
if (nums1[i - 1] == nums2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
return dp[nums1.size()][nums2.size()];
}
};
//动态规划
//时间复杂度O(n * m)
//空间复杂度O(n * m) 分析：
绘制一些连接两个数字 A[i] 和 B[j] 的直线，只要 A[i] == B[j]，且直线不能相交！
直线不能相交，这就是说明在字符串A中 找到一个与字符串B相同的子序列，且这个子序列不能改变相对顺序，只要相对顺序不改变，链接相同数字的直线就不会相交。
本题说是求绘制的最大连线数，其实就是求两个字符串的最长公共子序列的长度！
以A = [1,4,2], B = [1,2,4]为例，相交情况如图：
本题本质与 例2：1143. 最长公共子序列 - 力扣（LeetCode）相同，代码一模一样！
分类二：子序列（连续）问题
例1：674. 最长连续递增序列 - 力扣（LeetCode）
解法一：动态规划
class Solution {
public:
int findLengthOfLCIS(vector& nums) {
if (nums.size() == 0) return 0;
vector dp(nums.size(), 1);
int result = 1;
for (int i = 1; i < nums.size(); i++) {
if (nums[i] > nums[i - 1]) {//连续记录
dp[i] = dp[i - 1] + 1;
}
if (dp[i] > result) result = dp[i];
}
return result;
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n) 分析：
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[i]：以下标i为结尾的连续递增的子序列长度为dp[i]。
注意这里的定义，一定是以下标i为结尾，并不是说一定以下标0为起始位置。
2、确定递推公式
如果 nums[i] > nums[i - 1]，那么以 i 为结尾的连续递增的子序列长度 一定等于 以i - 1为结尾的连续递增的子序列长度 + 1 。
即：dp[i] = dp[i - 1] + 1;
注意这里就体现出和分类一中 例1：300. 最长递增子序列 - 力扣（LeetCode）的区别！
因为本题要求连续递增子序列，所以就只要比较nums[i]与nums[i - 1]，而不用去比较nums[j]与nums[i] （j是在0到i之间遍历）。
既然不用j了，那么也不用两层for循环，本题一层for循环就行，比较nums[i] 和 nums[i - 1]。
3、dp数组如何初始化
以下标i为结尾的连续递增的子序列长度最少也应该是1，即就是nums[i]这一个元素。
所以dp[i]应该初始1;
4、确定遍历顺序
从递推公式上可以看出， dp[i + 1]依赖dp[i]，所以一定是从前向后遍历。
for (int i = 1; i < nums.size(); i++) {
if (nums[i] > nums[i - 1]) { // 连续记录
dp[i] = dp[i - 1] + 1;
}
}
5、举例推导dp数组
已输入nums = [1,3,5,4,7]为例，dp数组状态如下：
注意这里要取dp[i]里的最大值，所以dp[2]才是结果！
解法二：贪心算法
class Solution {
public:
int findLengthOfLCIS(vector& nums) {
if (nums.size() == 0) return 0;
int result = 1;
int count = 1;
for (int i = 1; i < nums.size(); i++) {
if (nums[i] > nums[i - 1]) {
count++;
} else {
count = 1;
}
if (count > result) {
result = count;
}
}
return result;
}
};
//贪心算法
//时间复杂度O(n)
//空间复杂度O(1) 不连续递增子序列的跟前0-i 个状态有关（两层for循环遍历），连续递增的子序列只跟前一个状态有关（一层for循环遍历）。
例2： 718. 最长重复子数组 - 力扣（LeetCode）
class Solution {
public:
int findLength(vector& nums1, vector& nums2) {
vector> dp(nums1.size() + 1, vector(nums2.size() + 1, 0));
int result = 0;
for (int i = 1; i <= nums1.size(); i++) {
for (int j = 1; j <= nums2.size(); j++) {
if (nums1[i - 1] == nums2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
}
if (dp[i][j] > result) result = dp[i][j];
}
}
return result;
}
};
//动态规划
//时间复杂度O(n * m)，n 为A长度，m为B长度
//空间复杂度O(n * m) 分析：
注意题目中说的子数组，其实就是连续子序列。
动规五部曲分析如下：
1、确定dp数组（dp table）以及下标的含义
dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。 （特别注意： “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 ）
2、确定递推公式
根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。
即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
根据递推公式可以看出，遍历i 和 j 要从1开始！
3、dp数组如何初始化
根据dp[i][j]的定义，dp[i][0] 和dp[0][j]其实都是没有意义的！
但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;
所以dp[i][0] 和dp[0][j]初始化为0。
举个例子A[0]如果和B[0]相同的话，dp[1][1] = dp[0][0] + 1，只有dp[0][0]初始为0，正好符合递推公式逐步累加起来。
4、确定遍历顺序
外层for循环遍历A，内层for循环遍历B。
外层for循环遍历B，内层for循环遍历A，也行。
题目要求长度最长的子数组的长度。所以在遍历的时候顺便把dp[i][j]的最大值记录下来。
代码如下：
for (int i = 1; i <= nums1.size(); i++) {
for (int j = 1; j <= nums2.size(); j++) {
if (nums1[i - 1] == nums2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
}
if (dp[i][j] > result) result = dp[i][j];
}
}
5、举例推导dp数组
例3：53. 最大子数组和 - 力扣（LeetCode）
class Solution {
public:
int maxSubArray(vector& nums) {
if (nums.size() == 0) return 0;
vector dp(nums.size(), 0);
dp[0] = nums[0];
int result = dp[0];
for (int i = 1; i < nums.size(); i++) {
dp[i] = max(dp[i - 1] + nums[i], nums[i]);// 状态转移公式
if (dp[i] > result) result = dp[i];// result 保存dp[i]的最大值
}
return result;
}
};
//动态规划
//时间复杂度O(n)
//空间复杂度O(n) 分析：
动规五部曲如下：
1、确定dp数组（dp table）以及下标的含义
dp[i]：包括下标i（以nums[i]为结尾）的最大连续子序列和为dp[i]。
2、确定递推公式
dp[i]只有两个方向可以推出来：
- dp[i - 1] + nums[i]，即：nums[i]加入当前连续子序列和
- nums[i]，即：从头开始计算当前连续子序列和
一定是取最大的，所以dp[i] = max(dp[i - 1] + nums[i], nums[i]);
3、dp数组如何初始化
从递推公式可以看出来dp[i]是依赖于dp[i - 1]的状态，dp[0]就是递推公式的基础。
根据dp[i]的定义，dp[0] = nums[0]。
4、确定遍历顺序
递推公式中dp[i]依赖于dp[i - 1]的状态，需要从前向后遍历。
5、举例推导dp数组
注意最后的结果可不是dp[nums.size() - 1]！ ，而是dp[6]。
在回顾一下dp[i]的定义：包括下标i之前的最大连续子序列和为dp[i]。
那么我们要找最大的连续子序列，就应该找每一个i为终点的连续最大子序列。
所以在递推公式的时候，可以直接选出最大的dp[i]。
分类三：编辑距离问题
例1： 392. 判断子序列 - 力扣（LeetCode）
解法一：动态规划
class Solution {
public:
bool isSubsequence(string s, string t) {
vector> dp(s.size() + 1, vector(t.size() + 1, 0));
for (int i = 1; i <= s.size(); i++) {
for (int j = 1; j <= t.size(); j++) {
if (s[i - 1] == t[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = dp[i][j - 1];
}
}
}
if (dp[s.size()][t.size()] == s.size()) return true;
return false;
}
};
//动态规划
//时间复杂度O(n * m)
//空间复杂度O(n * m) 分析：
动规五部曲分析如下：
1、确定dp数组（dp table）以及下标的含义
dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。
注意这里是判断s是否为t的子序列。即t的长度是大于等于s的。
2、确定递推公式
在确定递推公式的时候，首先要考虑如下两种操作，整理如下：
- if (s[i - 1] == t[j - 1])
- t中找到了一个字符在s中也出现了
- if (s[i - 1] != t[j - 1])
- 相当于t要删除元素，继续匹配
if (s[i - 1] == t[j - 1])，那么dp[i][j] = dp[i - 1][j - 1] + 1;，因为找到了一个相同的字符，相同子序列长度自然要在dp[i-1][j-1]的基础上加1。
if (s[i - 1] != t[j - 1])，此时相当于t要删除元素，t如果把当前元素t[j - 1]删除，那么dp[i][j] 的数值就是 看s[i - 1]与 t[j - 2]的比较结果了，即：dp[i][j] = dp[i][j - 1];
其实这里 大家可以发现和 例2：1143. 最长公共子序列 - 力扣（LeetCode）的递推公式基本是一样的，区别就是 本题 如果删元素一定是字符串t，而 1143.最长公共子序列 是两个字符串都可以删元素。
3、dp数组如何初始化
定义dp[i][j]表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。
这样的定义在dp二维矩阵中可以留出初始化的区间，如图：
dp[i][0] 表示以下标i-1为结尾的字符串，与空字符串的相同子序列长度，所以为0. dp[0][j]同理。
vector> dp(s.size() + 1, vector(t.size() + 1, 0)); 4、确定遍历顺序
同理从递推公式可以看出dp[i][j]都是依赖于dp[i - 1][j - 1] 和 dp[i][j - 1]，那么遍历顺序也应该是从上到下，从左到右
如图所示：
5、举例推导dp数组
dp[i][j]表示以下标i-1为结尾的字符串s和以下标j-1为结尾的字符串t 相同子序列的长度，所以如果dp[s.size()][t.size()] 与 字符串s的长度相同说明：s与t的最长相同子序列就是s，那么s 就是 t 的子序列。
图中dp[s.size()][t.size()] = 3， 而s.size() 也为3。所以s是t 的子序列，返回true。
解法二：双指针
class Solution {
public:
bool isSubsequence(string s, string t) {
int m = s.size(), n = t.size();
int i = 0, j = 0;
while (i < m && j < n) {
if (s[i] == t[j]) {
i++;
}
j++;
}
if (i == m) return true;
return false;
}
};
//双指针
//时间复杂度O(n)
//空间复杂度O(1)例2：115. 不同的子序列 - 力扣（LeetCode）
class Solution {
public:
int numDistinct(string s, string t) {
vector> dp(s.size() + 1, vector(t.size() + 1));
for (int i = 0; i <= s.size(); i++) dp[i][0] = 1;
for (int j = 1; j <= t.size(); j++) dp[0][j] = 0;
for (int i = 1; i <= s.size(); i++) {
for (int j = 1; j <= t.size(); j++) {
if (s[i - 1] == t[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[s.size()][t.size()];
}
};
//动态规划
//时间复杂度O(n * m)
//空间复杂度O(n * m) 浅析C语言之uint8_t / uint16_t / uint32_t /uint64_t_海阔天空sky1992的博客-CSDN博客
分析：
动规五部曲：
1、确定dp数组（dp table）以及下标的含义
dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。
2、确定递推公式
这一类问题，基本是要分析两种情况
- s[i - 1] 与 t[j - 1]相等
- s[i - 1] 与 t[j - 1] 不相等
当s[i - 1] 与 t[j - 1]相等时，dp[i][j]可以有两部分组成。
一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]。即不需要考虑当前s子串和t子串的最后一位字母，所以只需要 dp[i-1][j-1]。
一部分是不用s[i - 1]来匹配，个数为dp[i - 1][j]。
例如： s：bagg 和 t：bag ，s[3] 和 t[2]是相同的，但是字符串s也可以不用s[3]来匹配，即用s[0]s[1]s[2]组成的bag。
当然也可以用s[3]来匹配，即：s[0]s[1]s[3]组成的bag。
所以当s[i - 1] 与 t[j - 1]相等时，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
当s[i - 1] 与 t[j - 1]不相等时，dp[i][j]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素），即：dp[i - 1][j]
所以递推公式为：dp[i][j] = dp[i - 1][j];
注：为什么只考虑 “不用s[i - 1]来匹配” 这种情况， 不考虑 “不用t[j - 1]来匹配” 的情况呢？
因为求的是 s 中有多少个 t，而不是 求t中有多少个s，所以只考虑 s中删除元素的情况，即 不用s[i - 1]来匹配 的情况。
3、dp数组如何初始化
从递推公式dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; 和 dp[i][j] = dp[i - 1][j]; 中可以看出dp[i][j] 是从上方和左上方推导而来，如图：，那么 dp[i][0] 和dp[0][j]是一定要初始化的。
dp[i][0] 表示：以i-1为结尾的s可以随便删除元素，出现空字符串的个数。
那么dp[i][0]一定都是1，因为也就是把以i-1为结尾的s，删除所有元素，出现空字符串的个数就是1。
dp[0][j]：空字符串s可以随便删除元素，出现以j-1为结尾的字符串t的个数。
那么dp[0][j]一定都是0，s如论如何也变成不了t。
dp[0][0]应该是1，空字符串s，可以删除0个元素，变成空字符串t。
初始化分析完毕，代码如下：
vector> dp(s.size() + 1, vector(t.size() + 1));
for (int i = 0; i <= s.size(); i++) dp[i][0] = 1;
for (int j = 1; j <= t.size(); j++) dp[0][j] = 0; // 其实这行代码可以和dp数组初始化的时候放在一起，但我为了凸显初始化的逻辑，所以还是加上了。
4、确定遍历顺序
从递推公式dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; 和 dp[i][j] = dp[i - 1][j]; 中可以看出dp[i][j]都是根据左上方和正上方推出来的。
所以遍历的时候一定是从上到下，从左到右，这样保证dp[i][j]可以根据之前计算出来的数值进行计算。
代码如下：
for (int i = 1; i <= s.size(); i++) {
for (int j = 1; j <= t.size(); j++) {
if (s[i - 1] == t[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
} else {
dp[i][j] = dp[i - 1][j];
}
}
}5、举例推导dp数组
例3：583. 两个字符串的删除操作 - 力扣（LeetCode）
动态规划解法一：
class Solution {
public:
int minDistance(string word1, string word2) {
vector> dp(word1.size() + 1, vector(word2.size() + 1));
for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
for (int i = 1; i <= word1.size(); i++) {
for (int j = 1; j <= word2.size(); j++) {
if (word1[i - 1] == word2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1];
} else {
dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
}
}
}
return dp[word1.size()][word2.size()];
}
};
//动态规划
//时间复杂度O(n * m)
//空间复杂度O(n * m) 本题和 例2：115. 不同的子序列 - 力扣（LeetCode）相比，区别在于两个字符串都可以删除了，整体思路是不变的。
动规五部曲，分析如下：
1、确定dp数组（dp table）以及下标的含义
dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。
2、确定递推公式
- 当word1[i - 1] 与 word2[j - 1]相同的时候
- 当word1[i - 1] 与 word2[j - 1]不相同的时候
当word1[i - 1] 与 word2[j - 1]相同的时候，dp[i][j] = dp[i - 1][j - 1];
当word1[i - 1] 与 word2[j - 1]不相同的时候，有三种情况：
情况一：删word1[i - 1]，最少操作次数为dp[i - 1][j] + 1
情况二：删word2[j - 1]，最少操作次数为dp[i][j - 1] + 1
情况三：同时删word1[i - 1]和word2[j - 1]，操作的最少次数为dp[i - 1][j - 1] + 2
那最后当然是取最小值，所以当word1[i - 1] 与 word2[j - 1]不相同的时候，递推公式：dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});
因为 dp[i][j - 1] + 1 = dp[i - 1][j - 1] + 2，所以递推公式可简化为：dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
从字面上理解 就是 当 同时删word1[i - 1]和word2[j - 1]，dp[i][j-1] 本来就不考虑 word2[j - 1]了，那么再删 word1[i - 1]，就达到了两个元素都删除的效果，即 dp[i][j-1] + 1。
3、dp数组如何初始化
由递推公式可知，dp[i][0] 和 dp[0][j]是一定要初始化的。
dp[i][0]：word2为空字符串，以i-1为结尾的字符串word1要删除 i 个元素，才能和word2相同，所以dp[i][0] = i。
dp[0][j]同理，所以代码如下：
vector> dp(word1.size() + 1, vector(word2.size() + 1));
for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
4、确定遍历顺序
从递推公式 dp[i][j] = min(dp[i - 1][j - 1] + 2, min(dp[i - 1][j], dp[i][j - 1]) + 1); 和dp[i][j] = dp[i - 1][j - 1]可以看出dp[i][j]都是根据左上方、正上方、正左方推出来的。
所以遍历的时候一定是从上到下，从左到右，这样保证dp[i][j]可以根据之前计算出来的数值进行计算。
5、举例推导dp数组
以word1:"sea"，word2:"eat"为例，推导dp数组状态图如下：
动态规划解法二：
class Solution {
public:
int minDistance(string word1, string word2) {
vector> dp(word1.size() + 1, vector(word2.size() + 1, 0));
for (int i = 1; i <= word1.size(); i++) {
for (int j = 1; j <= word2.size(); j++) {
if (word1[i - 1] == word2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
return word1.size() + word2.size() - dp[word1.size()][word2.size()] * 2;
}
};
//动态规划
//时间复杂度O(n * m)
//空间复杂度O(n * m) 分析：
本题和 例2：1143. 最长公共子序列 - 力扣（LeetCode）基本相同，只要求出两个字符串的最长公共子序列长度即可，那么除了最长公共子序列之外的字符都是必须删除的，最后用两个字符串的总长度减去两个最长公共子序列的长度就是删除的最少步数。
例4：72. 编辑距离 - 力扣（LeetCode）
class Solution {
public:
int minDistance(string word1, string word2) {
vector> dp(word1.size() + 1, vector(word2.size() + 1, 0));
for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
for (int i = 1; i <= word1.size(); i++) {
for (int j = 1; j <= word2.size(); j++) {
if (word1[i - 1] == word2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1];
} else {
dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
}
}
}
return dp[word1.size()][word2.size()];
}
};
//动态规划
//时间复杂度O(n * m)
//空间复杂度O(n * m) 分析：
动规五部曲分析如下：
1、确定dp数组（dp table）以及下标的含义
dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i][j]。
2、确定递推公式
编辑情况分为以下四种：
if (word1[i - 1] == word2[j - 1])
不操作
if (word1[i - 1] != word2[j - 1])
增
删
换if (word1[i - 1] == word2[j - 1]) ：说明不用任何编辑，dp[i][j] 就应该是 dp[i - 1][j - 1]，即dp[i][j] = dp[i - 1][j - 1];
if (word1[i - 1] != word2[j - 1])，此时就需要编辑了：
- 操作一：word1删除一个元素，那么就是以下标i - 2为结尾的word1 与 j-1为结尾的word2的最近编辑距离 再加上一个操作。
即 dp[i][j] = dp[i - 1][j] + 1;
- 操作二：word2删除一个元素，那么就是以下标i - 1为结尾的word1 与 j-2为结尾的word2的最近编辑距离 再加上一个操作。
即 dp[i][j] = dp[i][j - 1] + 1;
为什么没有添加元素？
word2添加一个元素，相当于word1删除一个元素，例如 word1 = "ad" ，word2 = "a"，word1删除元素'd' 和 word2添加一个元素'd'，变成word1="a", word2="ad"， 最终的操作数是一样！
- 操作三：替换元素，
word1替换word1[i - 1]，使其与word2[j - 1]相同，此时不用增删元素。只需要一次替换的操作，就可以让 word1[i - 1] 和 word2[j - 1] 相同。
即 dp[i][j] = dp[i - 1][j - 1] + 1;
综上，当 if (word1[i - 1] != word2[j - 1]) 时取最小的，即：dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
递归公式代码如下：
if (word1[i - 1] == word2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1];
}
else {
dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
}3、dp数组如何初始化
dp[i][0] ：以下标i-1为结尾的字符串word1，和空字符串word2，最近编辑距离为dp[i][0]。
那么dp[i][0]就应该是i，对word1里的元素全部做删除操作，即：dp[i][0] = i;
同理dp[0][j] = j;
所以C++代码如下：
for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;4、确定遍历顺序
从如下四个递推公式：
dp[i][j] = dp[i - 1][j - 1]dp[i][j] = dp[i - 1][j - 1] + 1dp[i][j] = dp[i][j - 1] + 1dp[i][j] = dp[i - 1][j] + 1
可以看出dp[i][j]是依赖左方，上方和左上方元素的，如图：
所以在dp矩阵中一定是从左到右从上到下去遍历。
代码如下：
for (int i = 1; i <= word1.size(); i++) {
for (int j = 1; j <= word2.size(); j++) {
if (word1[i - 1] == word2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1];
}
else {
dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;
}
}
}5、举例推导dp数组
分类四：回文问题
例1：647. 回文子串 - 力扣（LeetCode）
解法一：动态规划
class Solution {
public:
int countSubstrings(string s) {
vector> dp(s.size(), vector(s.size(), false));
int result = 0;
for (int i = s.size() - 1; i >= 0; i--) {// 注意遍历顺序
for (int j = i; j 分析：
动规五部曲分析如下：
1、确定dp数组（dp table）以及下标的含义
判断一个子字符串（字符串的下表范围[i,j]）是否回文，依赖于，子字符串（下标范围[i + 1, j - 1]）） 是否是回文。
布尔类型的dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。
2、确定递推公式
当s[i]与s[j]不相等，dp[i][j]一定是false；
当s[i]与s[j]相等时，有如下三种情况：
- 情况一：下标i 与 j相同，同一个字符例如a，当然是回文子串；
- 情况二：下标i 与 j相差为1，例如aa，也是回文子串；
- 情况三：下标：i 与 j相差大于1的时候，例如cabac，此时s[i]与s[j]已经相同了，我们看i到j区间是不是回文子串就看aba是不是回文就可以了，那么aba的区间就是 i+1 与 j-1区间，这个区间是不是回文就看dp[i + 1][j - 1]是否为true。
递归公式如下：
if (s[i] == s[j]) {
if (j - i <= 1) { // 情况一 和 情况二
result++;
dp[i][j] = true;
} else if (dp[i + 1][j - 1]) { // 情况三
result++;
dp[i][j] = true;
}
}result就是统计回文子串的数量。
注意：这里没有列出当s[i]与s[j]不相等的情况，因为在下面dp[i][j]初始化的时候，就初始为false。
3、dp数组如何初始化
dp[i][j]初始化为false。
4、确定遍历顺序
由递推公式中可以看出，情况三是根据dp[i + 1][j - 1]是否为true，在对dp[i][j]进行赋值true的。
dp[i + 1][j - 1] 在 dp[i][j]的左下角，如图：
如果矩阵从上到下，从左到右遍历，那么会用到没有计算过的dp[i + 1][j - 1]，也就是根据不确定是不是回文的区间[i+1,j-1]，来判断了[i,j]是不是回文，那结果一定是不对的。
所以一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。
有的代码实现是优先遍历列，然后遍历行，其实也是一个道理，都是为了保证dp[i + 1][j - 1]都是经过计算的。
代码如下：
for (int i = s.size() - 1; i >= 0; i--) { // 注意遍历顺序
for (int j = i; j < s.size(); j++) {
if (s[i] == s[j]) {
if (j - i <= 1) { // 情况一 和 情况二
result++;
dp[i][j] = true;
} else if (dp[i + 1][j - 1]) { // 情况三
result++;
dp[i][j] = true;
}
}
}
}5、举例推导dp数组
举例，输入："aaa"，dp[i][j]状态如下：
图中有6个true，所以就是有6个回文子串。
注意因为dp[i][j]的定义，所以j一定是大于等于i的，那么在填充dp[i][j]的时候一定是只填充右上半部分。
解法二：双指针法
class Solution {
private:
int extend(const string& s, int i, int j, int n) {
int res = 0;
while (i >= 0 && j < n && s[i] == s[j]) {
i--;
j++;
res++;
}
return res;
}
public:
int countSubstrings(string s) {
int result = 0;
for (int i = 0; i < s.size(); i++) {
result += extend(s, i, i, s.size());// 以i为中心
result += extend(s, i, i + 1, s.size());// 以i和i+1为中心
}
return result;
}
};
//双指针
//时间复杂度O(n^2)
//空间复杂度O(1)例2：516. 最长回文子序列 - 力扣（LeetCode）
class Solution {
public:
int longestPalindromeSubseq(string s) {
vector> dp(s.size(), vector(s.size(), 0));
for (int i = 0; i < s.size(); i++) dp[i][i] = 1;
for (int i = s.size() - 1; i >= 0; i--) {
for (int j = i + 1; j < s.size(); j++) {
if (s[i] == s[j]) {
dp[i][j] = dp[i + 1][j - 1] + 2;
} else {
dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
}
}
}
return dp[0][s.size() - 1];
}
};
//动态规划
//时间复杂度O(n^2)
//空间复杂度O(n^2) 分析：
本题与 例1：647. 回文子串 - 力扣（LeetCode）有区别，回文子串是要连续的，回文子序列不是连续的！
动规五部曲分析如下：
1、确定dp数组（dp table）以及下标的含义
dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。
2、确定递推公式
在判断回文子串的题目中，关键逻辑就是看s[i]与s[j]是否相同。
如果s[i]与s[j]相同，那么dp[i][j] = dp[i + 1][j - 1] + 2;
如图：
如果s[i]与s[j]不相同，说明s[i]和s[j]的同时加入 并不能增加[i,j]区间回文子序列的长度，那么分别加入s[i]、s[j]看看哪一个可以组成最长的回文子序列。
加入s[j]的回文子序列长度为dp[i + 1][j]。
加入s[i]的回文子序列长度为dp[i][j - 1]。
那么dp[i][j]一定是取最大的，即：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
代码如下：
if (s[i] == s[j]) {
dp[i][j] = dp[i + 1][j - 1] + 2;
} else {
dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
}3、dp数组初始化
当i 和j 相同时，从递推公式：dp[i][j] = dp[i + 1][j - 1] + 2; 可以看出 递推公式是计算不到 i 和j相同时候的情况。
所以需要手动初始化一下，当i与j相同，那么dp[i][j]一定是等于1的，即：一个字符的回文子序列长度就是1。
其他情况dp[i][j]初始为0就行，这样递推公式：dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]); 中dp[i][j]才不会被初始值覆盖。
vector> dp(s.size(), vector(s.size(), 0));
for (int i = 0; i < s.size(); i++) dp[i][i] = 1; 4、确定遍历顺序
从递归公式中，可以看出，dp[i][j] 依赖于 dp[i + 1][j - 1] ，dp[i + 1][j] 和 dp[i][j - 1]，如图：
所以遍历i的时候一定要从下到上遍历，这样才能保证下一行的数据是经过计算的。
代码如下：
for (int i = s.size() - 1; i >= 0; i--) {
for (int j = i + 1; j < s.size(); j++) {
if (s[i] == s[j]) {
dp[i][j] = dp[i + 1][j - 1] + 2;
} else {
dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
}
}
}5、举例推导dp数组
红色框即：dp[0][s.size() - 1]; 为最终结果。