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 。
思路
dp[i]表示到"i"位置截至的最长递增子序列的长度,dp[i] = max(dp[i-1], count); 这里count还需要判断一下nums[i]和nums[i-1]的关系,来判断当前子序列是否是递增子序列。初始化dp[0] = 1;
但是这种方法只能处理连续的递增子序列,现在最长递增子序列可以是不连续的。
因此经过思考,我认为dp[i]应该存储两个值,一个是以nums[i]为结尾的最长递增子序列长度,另一个是不论是否以nums[i]为结尾的最长递增子序列长度;
- 以nums[i]为结尾的:dp[i][0] = maxn + 1 // maxn代表i之前比nums[i]小的,且为结尾的最大长度
- 因此maxn应该是max(num[j][0]);
- 不论是否以nums[i]为结尾:dp[i][1] = max(dp[i][0], i之前的全局最大值);
返回max(dp[nums.size()-1][0], dp[nums.size()-1][1]);
class Solution {
public:int lengthOfLIS(vector<int>& nums) {vector<vector<int>> dp(nums.size() + 1, vector<int>(2, 0));dp[0][0] = 1;dp[0][1] = 1;for (int i = 1; i < nums.size(); ++i) {int maxlow = 0;int maxn = 0;for (int j = 0; j < i; ++j) {if (nums[j] < nums[i] && dp[j][0] > maxlow) {maxlow = dp[j][0];}if (dp[j][0] > maxn || dp[j][1] > maxn) {maxn = max(dp[j][0], dp[j][1]);}}dp[i][0] = maxlow + 1;dp[i][1] = max(dp[i][0], maxn);}return max(dp[nums.size() - 1][0], dp[nums.size() - 1][1]);}
};
如果只用一维的dp数组,那么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的最大值。
之后还需要一步:
if (dp[i] > result) result = dp[i]; // 取长的子序列
- 时间复杂度: O(n^2)
- 空间复杂度: O(n)
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 隔开。
思路
这个题目感觉比上一题简单了很多,只需要用最开始的思路即可。
class Solution {
public:int findLengthOfLCIS(vector<int>& nums) {vector<int> dp(nums.size() + 1, 1);int count = 1;int result = 1;for (int i = 1; i < nums.size(); ++i) {if (nums[i] > nums[i-1]) {count++;dp[i] = max(dp[i], count);} else {count = 1;}if (dp[i] > result) {result = dp[i];}}return result;}
};
需要注意的是,我们不需要dp[i]来代表全局最长子序列,最长子序列只需要在得到每个以nums[i]为结尾的最长子序列之后比较一下result就可以了。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
718. 最长重复子数组
给两个整数数组 A 和 B ,返回两个数组中公共的、长度最长的子数组的长度。
示例:
输入:
- A: [1,2,3,2,1]
- B: [3,2,1,4,7]
- 输出:3
- 解释:长度最长的公共子数组是 [3, 2, 1] 。
思路
dp[i][j] :以下标i - 1为结尾的A,和以下标j - 1为结尾的B,最长重复子数组长度为dp[i][j]。 (特别注意: “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 )
其实dp[i][j]的定义也就决定着,我们在遍历dp[i][j]的时候i 和 j都要从1开始。
- 确定递推公式
根据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;
根据递推公式可以看出,遍历i 和 j 要从1开始!
- dp数组如何初始化
根据dp[i][j]的定义,dp[i][0] 和dp[0][j]其实都是没有意义的!
但dp[i][0] 和dp[0][j]要初始值,因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;
所以dp[i][0] 和dp[0][j]初始化为0。
举个例子A[0]如果和B[0]相同的话,dp[1][1] = dp[0][0] + 1,只有dp[0][0]初始为0,正好符合递推公式逐步累加起来。
class Solution {
public:int findLength(vector<int>& nums1, vector<int>& nums2) {vector<vector<int>> dp(nums1.size() + 1, vector<int>(nums2.size() + 1, 0));int result = 0;for (int i = 1; i <= nums1.size(); ++i) {for (int j = 1; j <= nums2.size(); ++j) {if (nums1[i-1] == nums2[j-1]) {dp[i][j] = dp[i-1][j-1] + 1;}if (dp[i][j] > result) {result = dp[i][j];}}}return result;}
};
- 时间复杂度:O(n × m),n 为A长度,m为B长度
- 空间复杂度:O(n × m)