LeetCode 300.最长递增子序列
给你一个整数数组 nums ，返回其中最长递增子序列的长度。
视频讲解
https://www.bilibili.com/video/BV1ng411J7xP文章讲解 https://programmercarl.com/0300.%E6%9C%80%E9%95%BF%E4%B8%8A%E5%8D%87%E5%AD%90%E5%BA%8F%E5%88%97.html
- 思路：
- dp数组含义：dp[i]表示数组下标[0, i]中，以nums[i]结尾的最长递增子序列的长度
- 递推公式：
- 从0到 i - 1各个位置的最长递增子序列的长度 +1 的最大值
- if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
- 初始化：全1
- 遍历顺序：外层从左到右（dp[i]依赖于其左边的元素）内层从0到 i - 1或从 i - 1到0都可以
- 代码：
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if (nums.size() <= 1) return nums.size();
vector<int> dp(nums.size(), 1);
int result = 0;
for (int i = 1; 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;
}
};LeetCode 674. 最长连续递增序列
给定一个未经排序的整数数组，返回其中最长连续递增子序列的长度。
视频讲解https://www.bilibili.com/video/BV1bD4y1778v文章讲解https://programmercarl.com/0674.%E6%9C%80%E9%95%BF%E8%BF%9E%E7%BB%AD%E9%80%92%E5%A2%9E%E5%BA%8F%E5%88%97.html
- 思路：
- dp数组含义：dp[i]表示数组下标[0, i]中，以nums[i]结尾的最长递增子序列的长度
- 递推公式：
- 连续：只需要比较 nums[i] 和 nums[i - 1]
- nums[i] > nums[i - 1]👉dp[i] = dp[i - 1] + 1;（连上了，+1）
- 否则有dp[i] = 1;（没连上，从i位置重新开始）
- 初始化：全1
- 遍历顺序：从左到右
- 代码：
// 动规解法：
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
if (nums.size() == 0) return 0;
int result = 1;
vector<int> dp(nums.size() ,1);
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;
}
};
// 时间复杂度：O(n)
// 空间复杂度：O(n)// 贪心解法：遇到nums[i] > nums[i - 1]的情况，count就++，否则count为1，返回count的最大值
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
if (nums.size() == 0) return 0;
int result = 1; // 连续子序列最少也是1
int count = 1;
for (int i = 1; i < nums.size(); ++i) {
if (nums[i] > nums[i - 1]) { // 连续记录
count++;
} else { // 不连续，count从头开始
count = 1;
}
if (count > result) result = count;
}
return result;
}
};
// 时间复杂度：O(n)
// 空间复杂度：O(1)LeetCode 718. 最长重复子数组
给两个整数数组 nums1 和 nums2 ，返回两个数组中公共的、长度最长的子数组的长度。
注：子序列 vs 子数组（连续子序列）
视频讲解https://www.bilibili.com/video/BV178411H7hV文章讲解https://programmercarl.com/0718.%E6%9C%80%E9%95%BF%E9%87%8D%E5%A4%8D%E5%AD%90%E6%95%B0%E7%BB%84.html
- 思路：
- dp数组含义：
- dp[i][j]：以 nums1[i - 1] 结尾、以 nums2[j - 1] 结尾的最长重复子数组的长度
- 注：如果定义成以 nums1[i] 结尾、以 nums2[j] 结尾，dp[i][0] 和 dp[0][j]就有意义了，需要分别遍历 i 和 j 来初始化
- 递推公式：
- 当 nums1[i - 1] 和 nums2[j - 1] 相等时，dp[i][j] = dp[i - 1][j - 1] + 1;
- 初始化：
- 根据dp[i][j]的定义，dp[i][0] 和 dp[0][j] 都是没有意义的，初值符合递推公式即可
- 考虑：dp[i][1]👉比较 nums1[i - 1] 和 nums2[0]👉若相等则 dp[i][1] 为1
- 全部初始化为0
- 遍历顺序：
- 外层遍历 nums1、内层遍历 nums2，或者反过来都可以（两数组之间无顺序要求）
- 外层下标从小到大遍历（因为 dp[i][j] 依赖于 dp[i - 1][j - 1]）
- dp数组含义：
- 代码：
// 版本一
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为nums1长度，m为nums2长度
// 空间复杂度：O(n × m)// 版本二：滚动数组，内层循环一定要从后往前遍历
class Solution {
public:
int findLength(vector<int>& A, vector<int>& B) {
vector<int> dp(vector<int>(B.size() + 1, 0));
int result = 0;
for (int i = 1; i <= A.size(); i++) {
for (int j = B.size(); j > 0; j--) {
if (A[i - 1] == B[j - 1]) {
dp[j] = dp[j - 1] + 1;
} else dp[j] = 0; // 注意这里不相等的时候要有赋0的操作
if (dp[j] > result) result = dp[j];
}
}
return result;
}
};
// 时间复杂度：O(n × m)，n为A长度，m为B长度
// 空间复杂度：O(m)⭐总结：子序列 / 子数组问题
- dp数组含义：
- dp[i] 表示 以nums[i]结尾的最长...长度
- 如果涉及两个数组nums1、nums2👉dp[i][j] 表示 以nums1[?]结尾、以nums2[?]结尾...
- 递推公式：
- 搞清楚前一个状态是什么
- 根据题意，确定当前状态是 直接赋值 还是 取max / min
- 初始化：如果[0]无意义，通过递推公式倒推一个合法值
- 遍历顺序：外层/内层可否交换？每一层如何遍历？（从递推公式入手，看状态间依赖关系）
- 返回结果：有别于打家劫舍、股票问题，可能出现在任意下标，计算dp数组时顺便记录 result
