Date | 题目 | 题号 | 难度 | 方法 | 代码 |
---|---|---|---|---|---|
20230404 | (1)最长递增子序列 | leetcode 300 | Medium | DP or patience sorting | C++ |
20230404 | (2)俄罗斯套娃信封问题 | leetcode 354 | Hard | special sorting + patience sorting | C++ |
20230404 | (3)最大子数组和 | leetcode 53 | Medium | DP | C++ |
20230405 | (1)最长公共子序列 | leetcode 1143 | Medium | 二维 DP | C++ |
leetcode 300. 最长递增子序列
示例:
输入:nums = [10,9,2,5,3,7,101,18]
输出:4
解释:最长递增子序列是 [2,3,7,101],因此长度为 4 。
代码实现:
方法一:动态规划
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int n = nums.size();
// 初始化为1,表示从每个位置开始的最长递增子序列的长度至少为1
vector<int> dp(n, 1);
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
if (nums[i] > nums[j]) {
// 到第i个数,可能对应多个不同的递增子序列,
// 用max运算保证最终dp[i]是所有子序列中最长的长度
dp[i] = max(dp[i], dp[j] + 1);
}
}
}
for (int i = 0; i < n; ++i) {
res = max(res, dp[i]);
}
return res;
}
};
复杂度分析:
- 时间复杂度:两轮循环,故为 O ( n 2 ) O(n^2) O(n2) ;
- 空间复杂度:
dp
数组,空间复杂度为 O ( n ) O(n) O(n) 。
方法二:patience sorting
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int n = nums.size();
// 初始时预留n个位置用于放各个牌堆(这n个位置不一定会用完)
vector<int> pokerPiles(n, 0);
// 初始时,将牌堆数置为0
int pileNum = 0;
for (int i = 0; i < n; ++i) {
// right始终指向下一个空的牌堆
int left = 0, right = pileNum;
/*** 寻找左侧边界的二分搜索 ***/
while (left < right) {
int mid = left + (right - left) / 2;
if (pokerPiles[mid] < nums[i])
left = mid + 1;
else
right = mid;
}
// 如果左侧边界指向了下一个空牌堆的位置,让牌堆数加1
if (left == pileNum) ++pileNum;
// 将当前数字nums[i]放到left索引处
pokerPiles[left] = nums[i];
}
// 最终牌的堆数就是最长递增子序列的长度
return pileNum;
}
};
复杂度分析:
- 时间复杂度: O ( n log n ) O(n \log n) O(nlogn);
- 空间复杂度: O ( k ) O(k) O(k), k k k 是最长递增子序列的长度,最坏情况下是整个数组的长度,此时空间复杂度退化为 O ( n ) O(n) O(n) 。
leetcode 354. 俄罗斯套娃信封问题
输入:envelopes = [[5,4],[6,4],[6,7],[2,3]]
输出:3
解释:最多信封的个数为 3, 组合为: [2,3] => [5,4] => [6,7]。
代码实现:
class Solution {
public:
int maxEnvelopes(vector<vector<int>>& envelopes) {
int n = envelopes.size();
// 对envelopes的w按升序排列,h按降序排列
sort(envelopes.begin(), envelopes.end(), [](const auto& e1, const auto& e2) {
return e1[0] < e2[0] || (e1[0] == e2[0] && e1[1] > e2[1]);
});
// 接下来再求出h的最长递增子序列即可
// 用patience sorting算法
vector<int> pokerPiles(n, 0);
int pileNum = 0;
for (int i = 0; i < n; ++i) {
int left = 0, right = pileNum;
while (left < right) {
int mid = left + (right - left) / 2;
if (pokerPiles[mid] < envelopes[i][1]) left = mid + 1;
else right = mid;
}
if (left == pileNum) ++pileNum;
pokerPiles[left] = envelopes[i][1];
}
return pileNum;
}
};
复杂度分析:
- 时间复杂度: O ( n log n ) O(n \log n) O(nlogn)
leetcode 53. 最大子数组和
输入:nums = [-2,1,-3,4,-1,2,1,-5,4]
输出:6
解释:连续子数组 [4,-1,2,1] 的和最大,为 6 。
代码实现:
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int n = nums.size();
// 一维dp
vector<int> dp(n, 0);
// base case: 第一个元素前没有子数组
dp[0] = nums[0];
/*** DP ***/
// 因为已经处理了base case,故i从1开始
for (int i = 1; i < n; ++i) {
// dp数组的含义是: 以nums[i]结尾的“最大子数组和”为dp[i]
dp[i] = max(nums[i], nums[i] + dp[i-1]);
}
int maxSum = INT_MIN;
for (int i = 0; i < n; ++i) {
maxSum = max(maxSum, dp[i]);
}
return maxSum;
}
};
复杂度分析:
- 时间复杂度: O ( n ) O(n) O(n);
- 空间复杂度: O ( n ) O(n) O(n)。
leetcode 1143. 最长公共子序列
输入:text1 = "abcde", text2 = "ace"
输出:3
解释:最长公共子序列是 "ace" ,它的长度为 3 。
代码实现:
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
int m = text1.size(), n = text2.size();
vector<vector<int>> dp(m+1, vector<int>(n+1, 0));
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
if (text1[i-1] == text2[j-1]) {
dp[i][j] = dp[i-1][j-1] + 1;
} else {
dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
}
}
}
return dp[m][n];
}
};
复杂度分析:
- 时间复杂度: O ( m n ) O(mn) O(mn), m m m 和 n n n 分别是输入的两个字符串的长度;
- 空间复杂度: O ( m n ) O(mn) O(mn), m m m 和 n n n 分别是输入的两个字符串的长度。