大厂算法面试之leetcode精讲3.动态规划
视频教程（高效学习）:点击学习
目录：
10. 正则表达式匹配(hard)
方法1.动态规划
ds_78
ds_79
- 思路：
dp[i][j]表示 s 的前 i 个字符能否和p的前j个字符匹配，分为四种情况，看图 - 复杂度：时间复杂度
O(mn)，m,n分别是字符串s和p的长度，需要嵌套循环s和p。空间复杂度O(mn)，dp数组所占的空间
js:
//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串
};
Java:
class Solution {
public boolean isMatch(String s, String p) {
if (p==null){
if (s==null){
return true;
}else{
return false;
}
}
if (s==null && p.length()==1){
return false;
}
int m = s.length()+1;
int n = p.length()+1;
boolean[][]dp = new boolean[m][n];
dp[0][0] = true;
for (int j=2;j<n;j++){
if (p.charAt(j-1)=='*'){
dp[0][j] = dp[0][j-2];
}
}
for (int r=1;r<m;r++){
int i = r-1;
for (int c=1;c<n;c++){
int j = c-1;
if (s.charAt(i)==p.charAt(j) || p.charAt(j)=='.'){
dp[r][c] = dp[r-1][c-1];
}else if (p.charAt(j)=='*'){
if (p.charAt(j-1)==s.charAt(i) || p.charAt(j-1)=='.'){
dp[r][c] = dp[r-1][c] || dp[r][c-2];
}else{
dp[r][c] = dp[r][c-2];
}
}else{
dp[r][c] = false;
}
}
}
return dp[m-1][n-1];
}
}
312. 戳气球 (hard)
方法1:动态规划
ds_112
- 思路：
dp[i][j]表示开区间(i,j)能拿到的的金币，k是这个区间 最后一个 被戳爆的气球，枚举i和j，遍历所有区间，i-j能获得的最大数量的金币等于 戳破当前的气球获得的金钱加上之前i-k、k-j区间中已经获得的金币 - 复杂度：时间复杂度
O(n^3)，n是气球的数量，三层遍历。空间复杂度O(n^2)，dp数组的空间。
js：
var maxCoins = function (nums) {
const n = nums.length;
let points = [1, ...nums, 1]; //两边添加虚拟气球
const dp = Array.from(Array(n + 2), () => Array(n + 2).fill(0)); //dp数组初始化
//自底向上转移状态
for (let i = n; i >= 0; i--) {
//i不断减小
for (let j = i + 1; j < n + 2; j++) {
//j不断扩大
for (let k = i + 1; k < j; k++) {
//枚举k在i和j中的所有可能
//i-j能获得的最大数量的金币等于 戳破当前的气球获得的金钱加上之前i-k,k-j区间中已经获得的金币
dp[i][j] = Math.max(
//挑战最大值
dp[i][j],
dp[i][k] + dp[k][j] + points[j] * points[k] * points[i]
);
}
}
}
return dp[0][n + 1];
};
java：
class Solution {
public int maxCoins(int[] nums) {
int n = nums.length;
int[][] dp = new int[n + 2][n + 2];
int[] val = new int[n + 2];
val[0] = val[n + 1] = 1;
for (int i = 1; i <= n; i++) {
val[i] = nums[i - 1];
}
for (int i = n - 1; i >= 0; i--) {
for (int j = i + 2; j <= n + 1; j++) {
for (int k = i + 1; k < j; k++) {
int sum = val[i] * val[k] * val[j];
sum += dp[i][k] + dp[k][j];
dp[i][j] = Math.max(dp[i][j], sum);
}
}
}
return dp[0][n + 1];
}
}
343. 整数拆分 (medium)
ds_136
- 思路：
dp[i]为正整数i拆分之后的最大乘积，循环数字n，对每个数字进行拆分，取最大的乘积，状态转移方程：dp[i] = Math.max(dp[i], dp[i - j] * j, (i - j) * j)，j*(i-j)表示把i拆分为j和i-j两个数相乘，j * dp[i-j]表示把i拆分成j和继续把(i-j)这个数拆分，取(i-j)拆分结果中的最大乘积与j相乘 - 复杂度：时间复杂度
O(n^2)，两层循环。空间复杂度O(n)，dp数组的空间
js：
var integerBreak = function (n) {
//dp[i]为正整数i拆分之后的最大乘积
let dp = new Array(n + 1).fill(0);
dp[2] = 1;
for (let i = 3; i <= n; i++) {
for (let j = 1; j < i; j++) {
//j*(i-j)表示把i拆分为j和i-j两个数相乘
//j*dp[i-j]表示把i拆分成j和继续把(i-j)这个数拆分，取(i-j)拆分结果中的最大乘积与j相乘
dp[i] = Math.max(dp[i], dp[i - j] * j, (i - j) * j);
}
}
return dp[n];
};
java：
class Solution {
public int integerBreak(int n) {
int[] dp = new int[n+1];
dp[2] = 1;//初始状态
for (int i = 3; i <= n; ++i) {
for (int j = 1; j < i - 1; ++j) {
dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));
}
}
return dp[n];
}
}
0-1背包问题
0-1背包问题指的是有n个物品和容量为j的背包，weight数组中记录了n个物品的重量，位置i的物品重量是weight[i]，value数组中记录了n个物品的价值，位置i的物品价值是vales[i]，每个物品只能放一次到背包中，问将那些物品装入背包，使背包的价值最大。
举例：
ds_214
我们用动态规划的方式来做
状态定义：
dp[i][j]表示从前i个物品里任意取，放进容量为j的背包，价值总和最大是多少-
状态转移方程：
dp[i][j] = max(dp[i - 1][j],dp[i - 1][j - weight[i]] + value[i]); 每个物品有放入背包和不放入背包两种情况- 当
j - weight[i]<0：表示装不下i号元素了，不放入背包，此时dp[i][j] = dp[i - 1][j]，dp[i] [j]取决于前i-1中的物品装入容量为j的背包中的最大价值 - 当
j - weight[i]>=0：可以选择放入或者不放入背包。
放入背包则：dp[i][j] = dp[i - 1][j - weight[i]] + value[i]，dp[i - 1][j - weight[i]]表示i-1中的物品装入容量为j-weight[i]的背包中的最大价值，然后在加上放入的物品的价值value[i]就可以将状态转移到dp[i][j]。
不放入背包则：dp[i][j] = dp[i - 1] [j]，在这两种情况中取较大者。
- 当
-
初始化dp数组：
dp[i][0]表示背包的容积为0，则背包的价值一定是0，dp[0][j]表示第0号物品放入背包之后背包的价值ds_137 最终需要返回值：就是dp数组的最后一行的最后一列
循环完成之后的dp数组如下图
ds_138
js：
function testWeightBagProblem(wight, value, size) {
const len = wight.length,
dp = Array.from({ length: len + 1 }).map(//初始化dp数组
() => Array(size + 1).fill(0)
);
//注意我们让i从1开始，因为我们有时会用到i - 1，为了防止数组越界
//所以dp数组在初始化的时候，长度是wight.length+1
for (let i = 1; i <= len; i++) {
for (let j = 0; j <= size; j++) {
//因为weight的长度是wight.length+1，并且物品下标从1开始，所以这里i要减1
if (wight[i - 1] <= j) {
dp[i][j] = Math.max(
dp[i - 1][j],
value[i - 1] + dp[i - 1][j - wight[i - 1]]
)
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[len][size];
}
function test() {
console.log(testWeightBagProblem([1, 3, 4], [15, 20, 30], 4));
}
test();
状态压缩
根据状态转移方程dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i])，第i行只与第i-1行状态相关，所以我们可以用滚动数组进行状态压缩，其次我们注意到，j只与j前面的状态相关，所以只用一个数组从后向前计算状态就可以了。
function testWeightBagProblem2(wight, value, size) {
const len = wight.length,
dp = Array(size + 1).fill(0);
for (let i = 1; i <= len; i++) {
//从后向前计算，如果从前向后的话，最新的值会覆盖老的值，导致计算结果不正确
//dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - wight[i - 1]] + value[i - 1])
for (let j = size; j >= wight[i - 1]; j--) {
dp[j] = Math.max(dp[j], dp[j - wight[i - 1]] + value[i - 1] );
}
}
return dp[size];
}
416. 分割等和子集 （medium）
ds_140
- 思路：本题可以看成是0-1背包问题，给一个可装载重量为
sum / 2的背包和 N 个物品，每个物品的重量记录在 nums 数组中，问是否在一种装法，能够恰好将背包装满？dp[i][j]表示前i个物品是否能装满容积为j的背包，当dp[i][j]为true时表示恰好可以装满。每个数都有放入背包和不放入两种情况，分析方法和0-1背包问题一样。 - 复杂度：时间复杂度
O(n*sum)，n是nums数组长度，sum是nums数组元素的和。空间复杂度O(n * sum)，状态压缩之后是O(sum)
js：
//可以看成是0-1背包问题，给一个可装载重量为 sum / 2 的背包和 N 个物品，
//每个物品的重量记录在 nums 数组中，问是否在一种装法，能够恰好将背包装满？
var canPartition = function (nums) {
let sum = 0
let n = nums.length
for (let i = 0; i < n; i++) {
sum += nums[i]
}
if (sum % 2 !== 0) {//如果是奇数，那么分割不了，直接返回false
return false
}
sum = sum / 2
//dp[i][j]表示前i个物品是否能装满容积为j的背包，当dp[i][j]为true时表示恰好可以装满
//最后求的是 dp[n][sum] 表示前n个物品能否把容量为sum的背包恰好装满
//dp数组长度是n+1，而且是二维数组，第一维表示物品的索引，第二个维度表示背包大小
let dp = new Array(n + 1).fill(0).map(() => new Array(sum + 1).fill(false))
//dp数组初始化，dp[..][0] = true表示背包容量为0，这时候就已经装满了，
//dp[0][..] = false 表示没有物品，肯定装不满
for (let i = 0; i <= n; i++) {
dp[i][0] = true
}
for (let i = 1; i <= n; i++) {//i从1开始遍历防止取dp[i - 1][j]的时候数组越界
let num = nums[i - 1]
//j从1开始，j为0的情况已经在dp数组初始化的时候完成了
for (let j = 1; j <= sum; j++) {
if (j - num < 0) {//背包容量不足 不能放入背包
dp[i][j] = dp[i - 1][j];//dp[i][j]取决于前i-1个物品是否能前好装满j的容量
} else {
//dp[i - 1][j]表示不装入第i个物品
//dp[i - 1][j-num]表示装入第i个，此时需要向前看前i - 1是否能装满j-num
//和背包的区别，这里只是返回true和false 表示能否装满，不用计算价值
dp[i][j] = dp[i - 1][j] || dp[i - 1][j - num];
}
}
}
return dp[n][sum]
};
//状态转移方程 F[i, target] = F[i - 1, target] || F[i - 1, target - nums[i]]
//第 n 行的状态只依赖于第 n-1 行的状态
//状态压缩
var canPartition = function (nums) {
let sum = nums.reduce((acc, num) => acc + num, 0);
if (sum % 2) {
return false;
}
sum = sum / 2;
const dp = Array.from({ length: sum + 1 }).fill(false);
dp[0] = true;
for (let i = 1; i <= nums.length; i++) {
//从后向前计算，如果从前向后的话，最新的值会覆盖老的值，导致计算结果不正确
for (let j = sum; j > 0; j--) {
dp[j] = dp[j] || (j - nums[i] >= 0 && dp[j - nums[i]]);
}
}
return dp[sum];
};
java：
public class Solution {
public boolean canPartition(int[] nums) {
int len = nums.length;
int sum = 0;
for (int num : nums) {
sum += num;
}
if ((sum & 1) == 1) {
return false;
}
int target = sum / 2;
boolean[][] dp = new boolean[len][target + 1];
dp[0][0] = true;
if (nums[0] <= target) {
dp[0][nums[0]] = true;
}
for (int i = 1; i < len; i++) {
for (int j = 0; j <= target; j++) {
dp[i][j] = dp[i - 1][j];
if (nums[i] <= j) {
dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]];
}
}
if (dp[i][target]) {
return true;
}
}
return dp[len - 1][target];
}
}
//状态压缩
public class Solution {
public boolean canPartition(int[] nums) {
int len = nums.length;
int sum = 0;
for (int num : nums) {
sum += num;
}
if ((sum & 1) == 1) {
return false;
}
int target = sum / 2;
boolean[] dp = new boolean[target + 1];
dp[0] = true;
if (nums[0] <= target) {
dp[nums[0]] = true;
}
for (int i = 1; i < len; i++) {
for (int j = target; nums[i] <= j; j--) {
if (dp[target]) {
return true;
}
dp[j] = dp[j] || dp[j - nums[i]];
}
}
return dp[target];
}
}
198. 打家劫舍 （medium）
ds_148
- 思路：
dp[i]表示0-i能偷的最大金额，dp[i]由两种情况中的最大值转移过来-
dp[i - 2] + nums[i]表示偷当前位置，那么i-1的位置不能偷，而且需要加上dp[i-2],也就是前i-2个房间的金钱 -
dp[i - 1]表示偷当前位置，只偷i-1的房间
-
- 复杂度：时间复杂度
O(n)，遍历一次数组，空间复杂度O(1)，状态压缩之后是O(1)，没有状态压缩是O(n)
js：
//dp[i]表示0-i能偷的最大金额
const rob = (nums) => {
const len = nums.length;
const dp = [nums[0], Math.max(nums[0], nums[1])]; //初始化dp数组的前两项
for (let i = 2; i < len; i++) {
//从第三个位置开始遍历
//dp[i - 2] + nums[i] 表示偷当前位置，那么i-1的位置不能偷，
//而且需要加上dp[i-2],也就是前i-2个房间的金钱
//dp[i - 1]表示偷当前位置，只偷i-1的房间
dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
}
return dp[len - 1]; //返回最后最大的项
};
//状态压缩
var rob = function (nums) {
if(nums.length === 1) return nums[0]
let len = nums.length;
let dp_0 = nums[0],
dp_1 = Math.max(nums[0], nums[1]);
let dp_max = dp_1;
for (let i = 2; i < len; i++) {
dp_max = Math.max(
dp_1, //不抢当前家
dp_0 + nums[i] //抢当前家
);
dp_0 = dp_1; //滚动交换变量
dp_1 = dp_max;
}
return dp_max;
};
java:
class Solution {
public int rob(int[] nums) {
if (nums == null || nums.length == 0) {
return 0;
}
int length = nums.length;
if (length == 1) {
return nums[0];
}
int[] dp = new int[length];
dp[0] = nums[0];
dp[1] = Math.max(nums[0], nums[1]);
for (int i = 2; i < length; i++) {
dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
}
return dp[length - 1];
}
}
//状态压缩
class Solution {
public int rob(int[] nums) {
if (nums == null || nums.length == 0) {
return 0;
}
int len = nums.length;
int dp_0 = 0,
dp_1 = nums[0];
int dp_max = nums[0];
for (int i = 2; i <= len; i++) {
dp_max = Math.max(
dp_1, //不抢当前家
dp_0 + nums[i - 1] //抢当前家
);
dp_0 = dp_1; //滚动交换变量
dp_1 = dp_max;
}
return dp_max;
}
}
64. 最小路径和 (medium)
ds_205
- 思路：
dp[i][j]表示从矩阵左上角到（i，j）这个网格对应的最小路径和，只要从上到下，从左到右遍历网格，当前最小路径和就是当前的数值加上上面和左边左小的。 - 复杂度：时间复杂度
O(mn)，m、n分别是矩阵的长和宽。空间复杂度如果原地修改是O(1)，如果新建dp数组就是O(mn)
js：
var minPathSum = function(dp) {
let row = dp.length, col = dp[0].length
for(let i = 1; i < row; i++)//初始化第一列
dp[i][0] += dp[i - 1][0]
for(let j = 1; j < col; j++)//初始化第一行
dp[0][j] += dp[0][j - 1]
for(let i = 1; i < row; i++)
for(let j = 1; j < col; j++)
dp[i][j] += Math.min(dp[i - 1][j], dp[i][j - 1])//取上面和左边最小的
return dp[row - 1][col - 1]
};
java：
class Solution {
public int minPathSum(int[][] grid) {
if (grid == null || grid.length == 0 || grid[0].length == 0) {
return 0;
}
int rows = grid.length, columns = grid[0].length;
int[][] dp = new int[rows][columns];
dp[0][0] = grid[0][0];
for (int i = 1; i < rows; i++) {
dp[i][0] = dp[i - 1][0] + grid[i][0];
}
for (int j = 1; j < columns; j++) {
dp[0][j] = dp[0][j - 1] + grid[0][j];
}
for (int i = 1; i < rows; i++) {
for (int j = 1; j < columns; j++) {
dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
}
}
return dp[rows - 1][columns - 1];
}
}
