【LeetCode-300】最长递增子序列
问题
给定一个无序的整数数组，找到其中最长递增子序列的长度。
示例
输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的递增子序列是 [2,3,7,101]，它的长度是 4。
解答1：动态规划
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
int res = 0, n = nums.size();
vector<int> dp(n, 1);
for (int i = 1; i < n; i++) {
for(int j = 0; j < i; j++)
if (nums[j] < nums[i]) dp[i] = max(dp[j] + 1, dp[i]);
res = max(res, dp[i]);
}
return res;
}
};
重点思路
记动态规划数列dp，用于存储以该数结尾的最长上升子序列长度，最终输出dp数列中最大的值。时间复杂度O(n^2)。
解答2：贪心算法+二分查找
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if (nums.empty()) return 0;
vector<int> res{nums[0]};
for(int i = 1; i < nums.size(); i++) {
if (res.back() < nums[i]) res.push_back(nums[i]);
else { // 二分查找
int left = 0, right = res.size() - 1;
while (left < right) {
int mid = left + (right - left) / 2;
if (lis[mid] < nums[i]) left = mid + 1;
else right = mid;
}
res[left] = nums[i];
}
}
return res.size();
}
};
重点思路
考虑一个简单的贪心，如果我们要使上升子序列尽可能的长，则我们需要让序列上升得尽可能慢，因此我们希望每次在上升子序列最后加上的那个数尽可能的小。
维护一个数列lis，用于存放上升最慢的递增子序列。首先遍历输入数组，当前数的值为nums[i]，如果该数大于lis中最后的数，则pushback到最后，否则查找比nums[i]小且差的绝对值最小的一个数，用nums[i]替换该数对应的后一个数，保证递增的前提下使该序列上升得尽可能慢。
然后就是找这个需要替换的数的问题了。因为是递增数列，所以肯定用二分查找快。由上面的推导可知，从lis中取一个数，当这个数比nums[i]小时，那么需要替换的数肯定在这个数的后面。所以可以得到二分查找最关键的一句判断if (lis[mid] < nums[i]) left = mid + 1，剩下的就无脑写了。时间复杂度为O(nlog(n))。
解答3：贪心算法+二分查找（库函数lower_bound）
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if (nums.empty()) return 0;
vector<int> res{nums[0]};
for(int i = 1; i < nums.size(); i++) {
if (res.back() < nums[i]) res.push_back(nums[i]);
else *lower_bound(res.begin(), res.end(), nums[i]) = nums[i];
}
return res.size();
}
};
拓展
输出nums的最长递增子序列。（如果有多个答案，请输出其中 按数值(注：区别于按单个字符的ASCII码值)进行比较的 字典序最小的那个）
解答1:贪心算法+二分查找+恢复序列
class Solution {
public:
vector<int> LIS(vector<int>& nums) {
if (nums.empty()) return {};
int n = nums.size();
int maxLen[n]; maxLen[0] = 1;
vector<int> res{nums[0]};
for (int i = 1; i < n; i++) {
if (res.back() < nums[i]) {
res.push_back(nums[i]);
maxLen[i] = res.size();
}
else {
int pos = lower_bound(res.begin(), res.end(), nums[i]) - res.begin();
res[pos] = nums[i];
maxLen[i] = pos + 1; // 以当前数字结尾的最长递增子序列
}
}
for (int i = res.size() - 1, j = n - 1; i >= 0; j--) // i for res, j for nums
if (maxLen[j] == i + 1) res[i--] = nums[j];
return res;
}
};
重点思路
先使用贪心算法得到最长子序列长度，同时记录以当前位置结尾的子数组的最长递增子序列。最后我们得到一个maxLen数组，例如[1,2,3,2,3]，我们需要判断maxLen[2]与maxLen[4]选哪个。由于我们需要字典序最小，如果我们选maxLen[2]，则意味着必须保证nums[2] < nums[4]，此时maxLen[4] = 4，矛盾，所以有相同的数时取靠后的。
