一、子序列(不连续)
300. 最长递增子序列
题目链接
假设我们已经知道了 dp[0…4] 的所有结果,我们如何通过这些已知结果推出 dp[5] 呢?
nums[5] = 3,既然是递增子序列,我们只要找到前面那些结尾比 3 小的子序列,然后把 3 接到最后,就可以形成一个新的递增子序列,而且这个新的子序列长度加一
var lengthOfLIS = function(nums) {
const n = nums.length
// dp[i]代表0~i且以i结尾的数组最长递增子序列的长度,初始化的时候,长度均为为1,即本身。
const dp = new Array(n).fill(1);
// 遍历数组,对于每个位置都要去寻找最长递增子序列
for(let i=1; i<n; i++){
// 向前找比i小的数字j,比较j的最长递增子序列+1 和 i本身的大小
// 由于不要求连续,所以可以比较往前所有比i小的,拿到最大的即可
for(let j=0;j<i;j++){
if(nums[i] > nums[j]){
// 更新数组的值
dp[i] = Math.max(dp[i],dp[j]+1);
}
}
}
// 子序列是不连续的,不需要包括最后一个数字的,所以取dp数组中的最大
return Math.max(...dp);
};
1143. 最长公共子序列
1、二维dp数组
dp[i][j]的含义是第一个字符串前i个字符和第二个字符串前j个字符的最大公共子序列
(i , j用来遍历两个字符串的指针)
2、状态转移方程
3、状态的初始化
4、遍历过程
dp[i][j] 依赖与 dp[i - 1][j - 1] , dp[i - 1][j], dp[i][j - 1],所以 i 和 j 的遍历顺序肯定是从小到大的。
5、举例理解
var longestCommonSubsequence = function(text1, text2) {
const m = text1.length, n = text2.length;
// 1、dp[i][j]表示第一个字符串前i个字符和第二个字符串前j个字符的最长公共子序列长度
// 初始化公共子序列均为0,dp[0][0]表示空字符串,所以需要从dp[1][1]开始更新
const dp = new Array(m+1).fill().map(() => new Array(n+1).fill(0))
for(let i=1; i<=m; i++){
for(let j=1; j<=n; j++){
// 拿到两个字符串的最后一个字符
let c1 = text1[i-1], c2 = text2[j-1]
// 最后一个字符相等,就是之前相等的字符 + 1
if(c1 == c2){
dp[i][j] = dp[i-1][j-1] + 1
}else{
// 不相等
dp[i][j] = Math.max(dp[i-1][j],dp[i][j-1])
}
}
}
return dp[m][n]
};
二、子序列(连续)
连续子序列就相当于数组,所以定义 dp[i] 的时候是包括 i 在内的序列。并且最后的结果不是最后一个,而是选择dp数组中最大的。
674. 最长连续递增序列
var findLengthOfLCIS = function(nums) {
const n = nums.length
// dp[i]表示在0~i下标的数组包括i的连续递增子序列(数组)的长度,初始长度都是本身
const dp = new Array(n).fill(1)
for(let i=1;i<n;i++){
// 大于前一个,就是递增
if(nums[i]>nums[i-1]){
dp[i] = Math.max(dp[i],dp[i-1]+1)
}else{
// 小于前一个,就是递减。此时包括它本身的连续递增子序列就是自己
dp[i] = 1
}
}
// 拿到最大的数值,一维数组可以这么用,二维不可以
return Math.max(...dp)
};
718. 最长重复子数组
var findLength = function(nums1, nums2) {
// dp[i][j]为第一个数组的前i项包括i的子数组 和 第二个数组的前j项包括j的子数组的最长公共长度
const m = nums1.length, n = nums2.length;
const dp = new Array(m+1).fill().map(() => new Array(n+1).fill(0))
// 最大长度
let res = 0
for(let i=1; i<=m; i++){
for(let j=1; j<=n; j++){
// 拿到两个子数组的最后一个项
let c1 = nums1[i-1], c2 = nums2[j-1]
// 相等的话,可以考虑前面的,加上相等的这一项
// 不相等的话,由于子数组必须包括这项,所以相当于为0,即不存在重复子数组
if(c1 == c2){
dp[i][j] = dp[i-1][j-1] + 1
// 此时的最大长度就是dp[i][j]和res的最大值
// 最长重复子数组以哪一项结尾都有可能
res = Math.max(res,dp[i][j])
}
}
}
return res
};
53. 最大连续子数组和
思路和674差不多,一个是看连续子数组的长度,一个是看它们的和。都是把前面的状态加上自身 和 自身比,从而更新自身的状态。
/**
* @param {number[]} nums
* @return {number}
*/
var maxSubArray = function(nums) {
const n = nums.length
// dp[i]为0~i下标的数组包括i在内的最大子数组和
const dp = new Array(n)
// 初始化,最大的和就是本身
dp[0] = nums[0]
for(let i=1; i<n; i++){
// 以i结尾包括i在内的最大和
dp[i] = Math.max(nums[i],dp[i-1]+nums[i])
}
// 返回最大的即可
return Math.max(...dp)
};