算法学习——LeetCode力扣动态规划篇8
300. 最长递增子序列
描述
给你一个整数数组 nums ,找到其中最长严格递增子序列的长度。
子序列 是由数组派生而来的序列,删除(或不删除)数组中的元素而不改变其余元素的顺序。例如,[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的
子序列
。
示例
示例 1:
输入:nums = [10,9,2,5,3,7,101,18]
输出:4
解释:最长递增子序列是 [2,3,7,101],因此长度为 4 。
示例 2:
输入:nums = [0,1,0,3,2,3]
输出:4
示例 3:
输入:nums = [7,7,7,7,7,7,7]
输出:1
提示
1 <= nums.length <= 2500
-104 <= nums[i] <= 104
代码解析
动态规划
-
dp[i]的定义
dp[i]表示i之前包括i的以nums[i]结尾最长上升子序列的长度 -
状态转移方程
位置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的最大值。 -
dp[i]的初始化
每一个i,对应的dp[i](即最长上升子序列)起始大小至少都是1. -
确定遍历顺序
dp[i] 是有0到i-1各个位置的最长升序子序列 推导而来,那么遍历i一定是从前向后遍历。
j其实就是0到i-1,遍历i的循环在外层,遍历j则在内层
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if(nums.size() ==1 ) return 1;
vector<int> dp(nums.size() , 1);
int result = 0;
for(int i=0 ; 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;
}
};
674. 最长连续递增序列
描述
给定一个未经排序的整数数组,找到最长且 连续递增的子序列,并返回该序列的长度。
连续递增的子序列 可以由两个下标 l 和 r(l < r)确定,如果对于每个 l <= i < r,都有 nums[i] < nums[i + 1] ,那么子序列 [nums[l], nums[l + 1], …, nums[r - 1], nums[r]] 就是连续递增子序列。
示例
示例 1:
输入:nums = [1,3,5,4,7]
输出:3
解释:最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的,因为 5 和 7 在原数组里被 4 隔开。
示例 2:
输入:nums = [2,2,2,2,2]
输出:1
解释:最长连续递增序列是 [2], 长度为1。
提示
1 <= nums.length <= 104
-109 <= nums[i] <= 109
代码解析
动态规划
- dp数组定义
i点前连续递增序列的个数 - dp的迭代
if(nums[i] > nums[i-1]) dp[i] = dp[i-1] + 1;
当i的值大于i-1,dp[i] = dp[i-1] + 1 - dp初始化
全都设置为1
自己认为是一个元素的递增数组
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
if(nums.size()==1) return 1;
vector<int> dp(nums.size() ,1);
int result = 0;
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;
}
};
718. 最长重复子数组
描述
给两个整数数组 nums1 和 nums2 ,返回 两个数组中 公共的 、长度最长的子数组的长度 。
示例
示例 1:
输入:nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]
输出:3
解释:长度最长的公共子数组是 [3,2,1] 。
示例 2:
输入:nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]
输出:5
提示
1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 100
代码解析
动态规划
- 确定dp数组含义
dp[i][j] :以下标i - 1为结尾的A(A的第i个元素),和以下标j - 1为结尾的B(B的第j个元素),最长重复子数组长度为dp[i][j]。 - 确定递推公式
根据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; - 初始化
dp[0][0]、dp[i][0]、dp[0][j]都为0,因为下标为0意味着没有元素进行匹配,因此匹配的个数也是0。从dp[i][j]开始有意义,即nums1和nums2都拿出了一个元素
class Solution {
public:
int findLength(vector<int>& nums1, vector<int>& nums2) {
//dp数组下标i和j意味着第几个元素,因此长度+1
vector<vector<int>> dp(nums1.size()+1 , vector<int>(nums2.size()+1,0));
int result = 0 ;
for(int i=0 ; i<nums1.size() ;i++)
{
for(int j=0 ;j<nums2.size();j++)
{
if(nums1[i] == nums2[j])
dp[i+1][j+1] = dp[i][j]+1;
if(dp[i+1][j+1] > result) result = dp[i+1][j+1];
}
}
// for(int i=0 ; i<=nums1.size() ;i++)
// {
// for(int j=0 ;j<=nums2.size();j++)
// {
// if(dp[i][j] > result) result = dp[i][j];
// cout<<dp[i][j]<<' ';
// }
// cout<<endl;
// }
return result;
}
};
1143. 最长公共子序列
描述
给定两个字符串 text1 和 text2,返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ,返回 0 。
一个字符串的 子序列 是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。
例如,“ace” 是 “abcde” 的子序列,但 “aec” 不是 “abcde” 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。
示例
示例 1:
输入:text1 = “abcde”, text2 = “ace”
输出:3
解释:最长公共子序列是 “ace” ,它的长度为 3 。
示例 2:
输入:text1 = “abc”, text2 = “abc”
输出:3
解释:最长公共子序列是 “abc” ,它的长度为 3 。
示例 3:
输入:text1 = “abc”, text2 = “def”
输出:0
解释:两个字符串没有公共子序列,返回 0 。
提示
1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由小写英文字符组成。
代码解析
- dp数组含义
dp[i][j]:长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j](即前i个字符和前j个字符匹配) - 递推公式
- 当text1[i] == text2[j]
当前匹配的i和j是相同的字符,dp[i+1][j+1] = dp[i][j] + 1;
dp应该是不包括第i+1 和第j+1字符之前匹配成功个数+1
要把i+1和j+1让出来。 - 当text1[i] != text2[j]
当前匹配的i和j是不同的字符,dp[i+1][j+1] = max(dp[i+1][j],dp[i][j+1]);
dp为包括i+1字符或者包括j+1字符的最大值 - 当匹配成功时
为什么不是 dp[i+1][j+1] = max(dp[i+1][j],dp[i][j+1])+1;
因为会造成一个字母匹配多次
例如 text1中有一个b,text2中有两个b
在i+1为text1的b,j+1为text2中第二个b时:
max(dp[i+1][j],dp[i][j+1])包含和text2中第一个b匹配,+1是和第二个b匹配。
则造成了text1中字母b与text2中两个b分别匹配。
因此应该是dp[i+1][j+1] = dp[i][j] + 1,这样让开要匹配的字符
- 当text1[i] == text2[j]
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
vector<vector<int>> dp(text1.size()+1 , vector<int>(text2.size()+1 ,0) );
for(int i=0 ;i<text1.size();i++)
{
for(int j=0; j<text2.size();j++)
{
if(text1[i] == text2[j])
dp[i+1][j+1] = dp[i][j] + 1;
else
dp[i+1][j+1] = max(dp[i+1][j],dp[i][j+1]);
}
}
// for(int i=0 ;i<=text1.size();i++)
// {
// for(int j=0; j<=text2.size();j++)
// {
// cout<<dp[i][j]<<' ';
// }
// cout<<endl;
// }
return dp[text1.size()][text2.size()];
}
};