目录
一、解题步骤
今天解决的是动态规划章节的子序列问题,共探讨了三道题。这类题一般可通过以下步骤完成:
1. 定义状态
首先,需要定义动态规划数组(通常称为dp数组)及其状态含义。对于子序列问题,dp[i]通常表示以第i个元素结尾的子序列的某种性质(如最长长度、最大/最小值等)。
2. 确定状态转移方程
状态转移方程是动态规划的核心,它描述了如何从一个或多个已知状态推导出下一个状态。对于子序列问题,通常需要考虑以下几种情况:
最长子序列(LIS,Longest Increasing Subsequence):
dp[i] = max(dp[i], dp[j] + 1)
解释:如果nums[i]大于nums[j],那么nums[i]可以接在以nums[j]结尾的最长子序列后面,形成一个更长的子序列。
最长公共子序列(LCS,Longest Common Subsequence):
if (nums1[i] == nums2[j]) dp[i][j] = dp[i - 1][j - 1] + 1
else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
解释:如果nums1[i]等于nums2[j],则当前字符可以加入LCS;否则,取不包含nums1[i]或nums2[j]中的较大者。
3. 初始化边界条件
确定dp数组的初始值。对于子序列问题,通常有以下几种初始化方式:
单序列问题:dp[0] = 1(表示单个元素的最长/最大子序列长度/值)
双序列问题:dp[0][j]和dp[i][0]初始化为0(表示一个序列为空时的子序列长度)
4. 遍历顺序
根据状态转移方程,确定dp数组的遍历顺序。通常,遍历顺序是按照子序列的长度递增的顺序进行的。
5. 返回结果
根据问题的要求,返回最终的dp数组值或根据dp数组计算出的结果。
二、题目与题解
题目一: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数组中dp[i]表示的含义:
dp[i]:以位置 i 结尾的最长递增子序列的长度。需要理解的一个点就是这里的dp[i]是明确以 i 结尾,而不是 i 之前某个位置。
然后就是初始化的考虑:上边提到,单序列问题初始化 dp[0] = 1,在这里,我们需要初始化所有dp数组元素为1,表示任意递增子序列至少有一个元素。
最后就是递推方程的确立,当前的 dp[i] 将由在当前位置 i 之前的 dp[j] 得来,我们要得到以 i 结尾的递增子序列长度的最大值,就需要遍历所有当前位置 i 之前的位置 j ,比较所有递增序列,取最大值即可。
for (int i = 1; i < n; i++) {
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
dp[i] = max(dp[i], dp[j] + 1);
}
}
ans = max(ans, dp[i]);
}
注意,这里最终的结果 ans 就是处于所有位置的 i 的最长递增子序列中的最大长度--我们可以在循环中一并比较,不断更新这个值。
完整代码如下:
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int n = nums.size();
if (n == 0 || n == 1) {
return n;
}
vector<int> dp(n, 1); //dp[i]:以位置 i 结尾的最长递增子序列的长度(注意:必须以nums[i]结尾);注意初始化所有元素为1;每一个 i,对应的 dp[i](即最长递增子序列)起始大小至少都是1
int ans = 0; //记录结果
for (int i = 1; i < n; i++) { //从第二个元素开始遍历当前元素
for (int j = 0; j < i; j++) { //内层循环,遍历当前位置 i 之前的所有元素
if (nums[i] > nums[j]) {
dp[i] = max(dp[i], dp[j] + 1); //注意这里不是要dp[i] 与 dp[j] + 1进行比较,而是我们要取dp[j] + 1的最大值 -- 多个 j 下的最大值,才是当前位置 i 对应的最大长度
}
}
ans = max(ans, dp[i]); //更新结果变量,取 dp 数组中的最大值 -- 所有元素 i 结尾情况的最大值
}
return ans;
}
};
题目二: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
题解:动态规划
这道题感觉比上一道简单,已经确定是连续的递增序列了,就只需要比较相邻的两个元素的大小,就能够确定以当前位置 i 结尾的最长连续递增序列的长度。
代码如下:
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
int n = nums.size();
if (n == 0 || n == 1) {
return n;
}
vector<int> dp(n, 1); //dp[i]:以位置 i 结尾的最长递增子序列的长度(注意:必须以nums[i]结尾),初始化所有元素为1:最长递增子序列至少一个元素
int ans = 0;
for (int i = 1; i < n; i++) {
if (nums[i] > nums[i - 1]) { //连续递增--只考虑相邻元素
dp[i] = dp[i - 1] + 1;
}
ans = max(ans, dp[i]); //不断更新,取每个位置 i 结尾的最长连续递增子序列的的最大长度
}
return ans;
}
};
题目三: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数组来解决这个问题。
dp[i][j]:以下标 i-1 为结尾的nums1,和以下标 j-1 为结尾的nums2,最长重复子数组长度为 dp[i][j]。这就很容易搞错了,我们这样设置的缘由就是当前位置(i, j)是由前一个元素(i - 1, j)得来,为了防止越界,我们选择这样设置。
然后一个注意的点就是双序列问题,dp数组所有元素都初始化为0。
最后就是公共子序列就是要求对应元素一致:这里的判断条件就是dp数组前一个元素对应的两个数组的元素一样,即:
if (nums1[i - 1] == nums2[j - 1])
这时就能满足当前位置由前一个位置长度+1。(多了当前判断元素)
代码如下:
class Solution {
public:
int findLength(vector<int>& nums1, vector<int>& nums2) {
int n = nums1.size();
int m = nums2.size();
vector<vector<int>> dp (n + 1, vector<int>(m + 1, 0)); //dp[i][j]:以下标i-1为结尾的nums1,和以下标j-1为结尾的nums2,最长重复子数组长度为dp[i][j](因此i,j循环都从1开始);初始化所有元素为0
int ans = 0;
for (int i = 1; i <= n; i++) { //外层循环,遍历nums1的所有元素
for (int j = 1; j <= m; j++) { //内层循环,遍历nums2的所有元素
if (nums1[i - 1] == nums2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1; //如果nums1的第i-1个元素(从0开始计数)等于nums2的第j-1个元素,则当前最长公共子序列长度为前一个元素的最长公共子序列长度+1
}
ans = max(ans, dp[i][j]); //不断更新结果变量 -- 取得以任意位置(i - 1, j - 1)结尾的最长重复子数组的长度的最大值
}
}
return ans;
}
};
三、小结
今天的题目整体来说难度不大,但也算是提供了一种新的思路,dp数组的具体含义也有别于前边的练习,不过作为子序列内容的基础,理解还是很重要的。后边继续加油!