- 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);
- 每一个i,对应的dp[i](即最长递增子序列)起始大小至少都是1
- dp[i] 与 0 - i 的dp值有关,所以需要从前往后便利
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
vector<int> dp(nums.size(), 1);
int maxlen = 0;
for(int i = 0; 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] > maxlen){
maxlen = dp[i];
}
}
return maxlen;
}
};
上述动态规划的解法,其时间复杂度为O(N * N),力扣进阶所要求的时间复杂度为O(NlogN),需要使用贪心的思想来进行实现。
利用贪心的思想维护一个单调递增数组 d[i] ,表示长度为 i 的最长上升子序列的末尾元素的最小值,用 len 记录目前最长上升子序列的长度,起始时 len 为 1,d[1]=nums[0];
- 遍历到新的 nums 数组元素,如果 nums[i] > dp[len],将其加入到单调递增数组的 len + 1位置,此时单调递增的子序列长度变为 len + 1,其末尾元素为 nums[i]‘
- 如果 nums[i] < dp[len], 那么在 维护的单调递增数组dp[i]中,使用 二分查找 来找到其位置,并更新 dp[pos + 1], 使更新后的序列,同样满足单调递增,这里采用二分查找,用来降低时间复杂度。
- 当单调递增子序列 dp[i] 中查找不到 nums[i] 的位置,那么说明这个序列的值都比 nums[i] 大,那么说明需要更新 dp[1] 的值。
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
vector<int> dp(nums.size() + 1, 0);
int len = 1;
dp[len] = nums[0];
for(int i = 1; i < nums.size(); i++){
if(nums[i] > dp[len]){
dp[++len] = nums[i];
} else{
int l = 1, r = len, pos = 0;
while(l <= r){
int mid = l + (r - l) / 2;
if(dp[mid] < nums[i]){
pos = mid;
l = mid + 1;
}else{
r = mid - 1;
}
}
dp[pos + 1] = nums[i];
}
}
return len;
}
};