1. 概念
动态规划（Dynamic Programming）
- 递归是从顶部开始将问题分解，通过解决掉所有分解出小问题的方式，来解决整个问题。
- 动态规划解决方案从底部开始解决问题，将所有小问题解决掉，然后合并成一个整体解决方案，从而解决掉整个大问题。也可以称为递推。
- 将一个大的问题拆分成一个个子问题，我们把它称之为子结构。
- 每个最优解，也就是最优值均由[这些小规模子问题]推到而来。
- 更重要的就是利用
历史记录，来避免我们重复的计算。
常用的公式 f(n) = min(f(n-1),f(n-2)) + k
贪心算法
- 只是局部最优
- 如 ：要在金额 1,8,13 的找到16 最少的组合硬币， 贪心从 最大开始 13+ 1+1+1
- 而如果用动态规划，可以找到是 8 + 8
背包问题
1. 01背包问题
已知只有物品数量不重复，只有一件，求最大放入包的总价值
问题：
已知：背包最大限制放5KG，有物品 [2KG：3W],[3KG：4W],[4KG：5W] 求背包可以放的最大价值？ weight = [2,3,4] ，value = [3,4,5] ， weightMax = 5 ，dp = [[]]
第一行遍历结果
遍历结果
核心公式
核心逻辑
-
i代表的物品下标，j代表这重量weight，遍历顺序是先遍历背包大小weight，再遍历物品goods
-
整个表格是从上到下，每一行一个物品，往下增加多一个，如第一行就只能放（物品[0]）, 第二行可以放（物品[0]）+ （物品[1]）
-
每一格根据当前行的重量判断是否可以放
- 不能放为：dp[i-1][j] ， [i-1]就是当前重量的上一个物品的最优最大值。
- 可以放为：dp[i-1][j-weight[i]] + value[i]。通过 当前背包(j) - 当前物品的重量(weight[i]) = 剩余可放重量(sub)。 dp[i-1][sub] 相当于是当前上一行里面 找剩下最优最大的值，取上一行是因为上一行还没包行当前行的物品， 当前行值 = dp[i-1][sub] + value[i] ，value[i]就是当前行物品的价值。最后比较 当前可放的物品值，与上一行最大值相比，取出最大赋值给当前行, Math.max(dp[i-1][j], dp[i-1][sub] )
- 一直遍历到最后一个dp[2][5] = 7w 就是最终要的最大值。
执行逻辑
答题
function backPack(weight, value, weightMax){
var goodsLen = weight.length -1
var dp = [[]]
for(var j = 0; j <= weightMax; j++){ //先直接计算出 第一个物品的可放价值，要么 0 ，要么是自己的价值如6
if(j < weight[0]){ //如果容量不能放下物品0的重量 2kg，那么价值为0
dp[0][j] = 0
}else{ //否则等于物体0的价值
dp[0][j] = value[0]
}
}
for(var j = 0; j <= weightMax; j++){ //先遍历背包限制
for(var i = 1; i <= goodsLen; i++ ){//遍历物品
if(!dp[i]){ //创建新一行
dp[i] = []
}
if(j < weight[i]){ //如果当前物品放不下当前背包，则取上一行最优最大值
// console.log(`当前背包${j}kg,物品${i}: 重量为${weight[i]},当前=上一个,取${dp[i][j]}`)
dp[i][j] = dp[i-1][j] //这里取得是上一个物品的值，当作 当前限制背包里面 的最大值
}else{
// console.log(`当前背包${j}kg,物品${i}: 重量为${weight[i]},当前=${dp[i-1][j-weight[i]]}+${value[i]}，上一个=${dp[i-1][j]},取${Math.max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])}`)
dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])
// 通过 当前背包(j) - 当前物品的重量(weight[i]) = 剩余可放重量(sub)
// dp[i-1][sub] 相当于是当前上一行里面 找剩下最优最大的值，取上一行是因为上一行还没包行当前行的物品，
// 当前行值 = dp[i-1][sub] + value[i] ，value[i]就是当前行物品的价值
// 最后比较 当前可放的物品值，与上一行最大值相比，取出最大赋值给当前行
// Math.max(dp[i-1][j], dp[i-1][sub] )
}
}
}
return dp[goodsLen][weightMax]
}
var max = backPack([2,3,4],[3,4,5],5)
console.log(max)
//优化代码
function backPack(weight, value, weightMax){
var goodsLen = weight.length;
var dp = new Array(goodsLen)
dp[-1] = new Array(weightMax+1).fill(0) //新增多一行物品 ，用于给 0行找 上一行 i - 1 的情况
// console.table(dp)
for(var i = 0 ; i < goodsLen ; i++){ //
dp[i] = new Array(weightMax).fill(0) //从第0行开始
for(var j=0; j<=weightMax; j++){//
if( j < weight[i] ){ //
dp[i][j] = dp[i-1][j] //这里i-1 就能找到 dp[-1][?] = 0 都等于0
}else{
dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-weight[i]]+value[i]);//
}
}
}
return dp[goodsLen-1][weightMax]
}
var max = backPack([2,3,4],[3,4,5],5)
console.log(max)
//压缩成1维数组
function backPack(weight, value, weightMax){
var goodsLen = weight.length;
var dp = new Array(weightMax+1).fill(0)
//这里的dp[i][j] 被压缩成 dp[j]
dp[j-weight[i]] +value[i]
for(var i = 0; i < goodsLen; i++) { //循环物品
for(var j = weightMax; j >= weight[i]; j--){ //循环重量，大到小循环， 从max=5到3，循环3次，从max=5到2 ，循环4次，这里只循环满足重量的
// console.log(`i:${i},j:${j},weight[i]:${weight[i]},dp[j]:${dp[j]},value[i]:${value[i]}`)
//依次从后往前获取最大值，并且覆盖原值
dp[j] = Math.max(dp[j], dp[j-weight[i]] +value[i]);
}
}
return dp[weightMax];
}
var max = backPack([3,2,2],[5,10,20], 5)
console.log(max)
//打印结果
i:0,j:5,weight[i]:3,dp[j]:0,dp[j-3]:0 + 5,取:5
i:0,j:4,weight[i]:3,dp[j]:0,dp[j-3]:0 + 5,取:5
i:0,j:3,weight[i]:3,dp[j]:0,dp[j-3]:0 + 5,取:5
i:1,j:5,weight[i]:2,dp[j]:5,dp[j-2]:5 + 10,取:15
i:1,j:4,weight[i]:2,dp[j]:5,dp[j-2]:0 + 10,取:10
i:1,j:3,weight[i]:2,dp[j]:5,dp[j-2]:0 + 10,取:10
i:1,j:2,weight[i]:2,dp[j]:0,dp[j-2]:0 + 10,取:10
i:2,j:5,weight[i]:2,dp[j]:15,dp[j-2]:10 + 20,取:30
i:2,j:4,weight[i]:2,dp[j]:10,dp[j-2]:10 + 20,取:30
i:2,j:3,weight[i]:2,dp[j]:10,dp[j-2]:0 + 20,取:20
i:2,j:2,weight[i]:2,dp[j]:10,dp[j-2]:0 + 20,取:20
2.完全背包问题
已知固定几个面额货币，数量无限，可以任意组合，求指定金额可组合的最大数量
1.最优解，金额刚好等于面额
- 当面值刚好等于金额 ，就是最优解
- 比如：已知 面额为 1,2,5,7 ，求 2,5 的最优解 就是都是一张。
2.金额不等
如 ：已知 面额为 1,2,5,7 ， 求3或4的金额
-
求 金额为 3 ,需要选择金额小于3的来组合
-
方案1：先选1，剩2， 刚好2是也是面额,等于最优解1， 所以最优解是 两张 2
-
方案2：先选2，剩1， 刚好1是也是面额,等于最优解1 所以最优解是 两张 2
-
最终金额3 最优解就是 2
-
求 金额为 4 ,需要选择金额小于4的来组合
-
方案1：先选1，剩3，而刚才3的最优解是2， 所以最优解是 1+2 = 3
-
方案2：先选2，剩2， 刚好2是也是面额,等于最优解1 所以最优解是 1+1 = 2
-
最终金额4 最优解就是 2
由此就可以得出公式， 最优组合 = 1张面值 + 1个sub（总金额 - 面值）最优解(最优已经在前面计算好)
实例
已知 面值 [1,2,5,7] 钞票 , 求总金额9 ，需要多少张钞票？
-
金额为 0 ，默认设置为0
-
金额为 1 ，dp[1] = 1张面值 + dp[0] = 1 ，最优组合为1
-
金额为 2 dp[2] = 1张 1的面值 + dp[1] = 2 ，
dp[2] = 1张2的面值 + dp[0] = 1
由于dp[0] 比 dp[1] 小 ，取dp[0] , 最优组合为 1 -
金额为 3 dp[3] = 1张 1的面值 + dp[2] =2
dp[3] = 1张2的面值 + dp[1] = 2
由于dp[1] dp[2] 相等 , 最优组合为 2
以此推算下去，直到9
最后一个元素，dp[9] 就是最优的合计硬币数量
刷题
120. 三角形最小路径和
给定一个三角形 triangle ，找出自顶向下的最小路径和。
每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。
示例 1：
输入： triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
输出： 11
解释： 如下面简图所示：
2
3 4
6 5 7
4 1 8 3
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
示例 2：
输入： triangle = [[-10]]
输出： -10
答题
// @lc code=start
/**
* @param {number[][]} triangle
* @return {number}
*/
var minimumTotal = function(triangle) {
let len = triangle.length - 1
let tmp = triangle[len]
for(let i = len-1;i>=0;i--) {
for (let j = 0; j < triangle[i].length; j++) {
tmp[j] = triangle[i][j] + Math.min(tmp[j],tmp[j+1])
}
}
return tmp[0]
};
322零钱兑换
给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。
你可以认为每种硬币的数量是无限的。
示例 1：
输入： coins = [1, 2, 5], amount = 11
输出： 3
解释： 11 = 5 + 5 + 1
示例 2：
输入： coins = [2], amount = 3
输出： -1
示例 3：
输入： coins = [1], amount = 0
输出： 0
答题
/**
* @param {number[]} coins
* @param {number} amount
* @return {number}
*/
// [1,2,5]
// 11
var coinChange = function(coins, amount) {
let dp = new Array(amount + 1).fill(Infinity);//初始化dp数组，下标对应金额，值对应可以放的最小硬币数量
dp[0] = 0;//面额0只需要0个硬币兑换
for (let i = 1; i <= amount; i++) {//循环面额
for (let coin of coins) {//循环硬币数组
if (i - coin >= 0) {//核心逻辑，当可以用其中一个硬币的，
//就可以使用公式：当前金额-硬币金额=sub求最优+1，
//可以用公式 dp[i-coin] + 1 标识最优，(+1)是因为i-cion默认就会使用一个确定面额
// 在循环 coin of coins的时候，就是把 dp[i]是一直赋值更新，直到找到最小值。
dp[i] = Math.min(dp[i], dp[i - coin] + 1);
//注意dp 的所有值都是从下标小到大，一个个按顺序初始化最优值的，
//所以 假设当前i到13，那么1-12的最优解已经出来了，
}
}
}
return dp[amount] === Infinity ? -1 : dp[amount];//如果dp[amount] === Infinity，则无法兑换
};
72. 编辑距离
给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：
- 插入一个字符
- 删除一个字符
- 替换一个字符 示例 1：
输入： word1 = "horse", word2 = "ros"
输出： 3
解释：
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')
示例 2：
输入： word1 = "intention", word2 = "execution"
输出： 5
解释：
intention -> inention (删除 't')
inention -> enention (将 'i' 替换为 'e')
enention -> exention (将 'n' 替换为 'x')
exention -> exection (将 'n' 替换为 'c')
exection -> execution (插入 'u')
答题
解题思路
1. 定义 dp[i][j]
- dp[i][j] 代表 word1 中前 i 个字符，变换到 word2 中前 j 个字符，最短需要操作的次数
- 需要考虑 word1 或 word2 一个字母都没有，即全增加/删除的情况，所以预留 dp[0][j] 和 dp[i][0]
2.状态转移
- 如果刚好这两个字母相同 word1[i - 1] = word2[j - 1] ，那么可以直接参考 dp[i - 1][j - 1] ，操作不用加一
- 增，dp[i][j] = dp[i][j - 1] + 1
- 删，dp[i][j] = dp[i - 1][j] + 1
- 改，dp[i][j] = dp[i - 1][j - 1] + 1
- 按顺序计算，当计算 dp[i][j] 时，dp[i - 1][j] ， dp[i][j - 1] ， dp[i - 1][j - 1] 均已经确定了
- 配合增删改这三种操作，需要对应的 dp 把操作次数加一，取三种的最小
3.核心逻辑
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;
}
所以在dp矩阵中一定是从左到右从上到下去遍历。
最后一个元素 dp[word1.length][word2.length] 就是答案
4.dp 数组如何初始化
一个空串和一个非空串的编辑距离为 dp[i][0] = i 和 dp[0][j] = j，dp[i][0] 相当于对 word1 执行 i 次删除操作，dp[0][j] 相当于对 word1 执行 j 次插入操作。
let dp = Array.from(Array(word1.length + 1), () => Array(word2.length+1).fill(0));
for(let i = 1; i <= word1.length; i++) {
dp[i][0] = i;
}
for(let j = 1; j <= word2.length; j++) {
dp[0][j] = j;
}
答题
/**
* @param {string} word1
* @param {string} word2
* @return {number}
*
*
**/
//动态规划
const minDistance = (word1, word2) => {
let dp = Array.from(Array(word1.length + 1), () => Array(word2.length+1).fill(0));
for(let i = 1; i <= word1.length; i++) {
dp[i][0] = i;
}
for(let j = 1; j <= word2.length; j++) {
dp[0][j] = j;
}
for(let i = 1; i <= word1.length; i++) {
for(let j = 1; j <= word2.length; j++) {
if(word1[i-1] === word2[j-1]) {
dp[i][j] = dp[i-1][j-1];
} else {
dp[i][j] = Math.min(dp[i-1][j] + 1, dp[i][j-1] + 1, dp[i-1][j-1] + 1);
}
}
}
return dp[word1.length][word2.length];
};
//暴力穷举 + 递归
var minDistance = function(word1, word2) {
const dp = (i, j) => {
// 因为递归传入的是上一次的(i -1, j - 1)，所以这里都需要 + 1
if (i === -1) return j + 1 // s1走完了，将s2剩下的插入s1,需要j + 1步
if (j === -1) return i + 1 // s2走完了，删除s1剩下的，需要i + 1步
if (word1[i] === word2[j]) {
// 什么都不做，i,j向前移动一位
return dp(i - 1, j - 1)
} else {
// 找出最小的
return Math.min(
dp(i, j - 1) + 1, // 插入，在word1[i]中插入和word2[j]一样的字符，相当于把word2向前移动1位，word1不动
dp(i - 1, j) + 1, // 删除，把word1[i]删除，相当于word1向前移动1位,word2不动
dp(i - 1, j - 1) + 1 // 替换操作，都向前移动1位
)
}
}
// 从后往前遍历，i, j 初始化指向最后一个索引
return dp(word1.length - 1, word2.length - 1)
};
10. 正则表达式匹配
给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。
'.'匹配任意单个字符'*'匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。
示例 1：
输入： s = "aa" p = "a"
输出： false
解释： "a" 无法匹配 "aa" 整个字符串。
示例 2:
输入： s = "aa" p = "a*"
输出： true
解释： 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
示例 3：
输入： s = "ab" p = ".*"
输出： true
解释： ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
示例 4：
输入： s = "aab" p = "c*a*b"
输出： true
解释： 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
解题思路
假设s=abbcddd,p=a*b*.dd*,因此先建立一张对应二维数组的表:
依次填如关系表
第一步：明确状态dp[i][j]的含义：
dp[i][j]: 表示s的前i个字符与p的前j个字符是否匹配，结果用boolean类型表示。
第二步：分析状态转移方程：
对于p，其只可能有三种情况：
- （1）小写字母a-z；
- （2）点号'.';
- （3）星号'*';
第一种情况：
p是小写字母，那么我们只需要判断s[i]是否等于p[j]
dp[i][j] = dp[i - 1][j - 1]; (s[i] == p[j])
dp[i][j] = false; (s[i] != p[j])
第二种情况：
由于p == '.'，因此p可以匹配任一字符，所以：
dp[i][j] = dp[i - 1][j - 1];
第三种情况：
p是''，对于'x'意思是：匹配零次或多次x。因此也是最复杂的情况了。对于s[i]和p[j-1]，
我们可以再细分为两种情况：
（1）s[i]与p[j-1]不匹配
对于不匹配来讲，也就是'x*'匹配零次，即不使用'x*'，所以此时的状态转移方程为：dp[i][j] = dp[i][j - 2]。
不匹配条件表示为s[i] != p[j-1]，但是只是如此吗？不是的！如果p[j-1]是点号'.'的话，那也是匹配的，所以：
dp[i][j] = dp[i][j - 2]; (s[i] != p[j-1] && p[j-1] != '.') \
（2）s[i]与p[j-1]匹配
对于匹配的情况而言，可以是匹配多次（dp[i][j] = dp[i-1][j]），也可以是匹配一次（dp[i][j] = dp[i][j-1]），
但是匹配多次是包含了匹配一次的情况，这里举个栗子：
s = “afs”，p = "afs*"
匹配多次：dp[3][4] = dp[2][4]
匹配一次：dp[3][4] = dp[3][3]
其实结果上是一样的，都是true，只不过这里dp[2][4]表示不使用"s*"时，s与p匹配，而dp[3][3]是直接匹配。
所以由上我们得到此种情况下的结论：dp[i][j] = dp[i-1][j]？
显然我们漏掉了一种情况，这里也是最重要的地方！也就是如果p[j-1]是'.'呢，那既然'.'可以表示任意一段字符串，有什么问题呢？同样来个栗子：
s = "ab"，p = "ab."，
dp[2][4]应该是true，但是按照上面的写法的话dp[2][4] = dp[1][4]就是false，这里应该匹配零次".*"，
即：
dp[2][4] = dp[2][2]。
因此，正确的结论是：
dp[i][j] = dp[i-1][j] || dp[i][j - 2];
答题
//dp[i][j]表示s的前i个字符能否和p的前j个字符匹配
const isMatch = (s, p) => {
if (s == null || p == null) return false;//极端情况 s和p都是空 返回false
const sLen = s.length, pLen = p.length;
const dp = new Array(sLen + 1);//因为位置是从0开始的，第0个位置是空字符串 所以初始化长度是sLen + 1
for (let i = 0; i < dp.length; i++) {//初始化dp数组
dp[i] = new Array(pLen + 1).fill(false); // 将项默认为false
}
// base case s和p第0个位置是匹配的
dp[0][0] = true;
for (let j = 1; j < pLen + 1; j++) {//初始化dp的第一列，此时s的位置是0
//情况1:如果p的第j-1个位置是*，则j的状态等于j-2的状态
//例如：s='' p='a*' 相当于p向前看2个位置如果匹配，则*相当于重复0个字符
if (p[j - 1] == "*") dp[0][j] = dp[0][j - 2];
}
// 迭代
for (let i = 1; i < sLen + 1; i++) {
for (let j = 1; j < pLen + 1; j++) {
//情况2:如果s和p当前字符是相等的 或者p当前位置是. 则当前的dp[i][j] 可由dp[i - 1][j - 1]转移过来
//当前位置相匹配，则s和p都向前看一位 如果前面所有字符相匹配 则当前位置前面的所有字符也匹配
//例如：s='XXXa' p='XXX.' 或者 s='XXXa' p='XXXa'
if (s[i - 1] == p[j - 1] || p[j - 1] == ".") {
dp[i][j] = dp[i - 1][j - 1];
} else if (p[j - 1] == "*") {//情况3:进入当前字符不匹配的分支 如果当前p是* 则有可能会匹配
//s当前位置和p前一个位置相同 或者p前一个位置等于. 则有三种可能
//其中一种情况能匹配 则当前位置的状态也能匹配
//dp[i][j - 2]：p向前看2个位置，相当于*重复了0次，
//dp[i][j - 1]：p向前看1个位置，相当于*重复了1次
//dp[i - 1][j]：s向前看一个位置，相当于*重复了n次
//例如 s='XXXa' p='XXXa*'
if (s[i - 1] == p[j - 2] || p[j - 2] == ".") {
dp[i][j] = dp[i][j - 2] || dp[i][j - 1] || dp[i - 1][j];
} else {
//情况4:s当前位置和p前2个位置不匹配，则相当于*重复了0次
//例如 s='XXXb' p='XXXa*' 当前位置的状态和p向前看2个位置的状态相同
dp[i][j] = dp[i][j - 2];
}
}
}
}
return dp[sLen][pLen]; // 长为sLen的s串 是否匹配 长为pLen的p串
};
