给定数组 [10, 9, 2, 5, 3, 7, 101, 18],其中一个最长递增子序列(不需要连续)为[2, 3, 7, 101] ,length为4。因为最长子序列不一定唯一,所以我们只需要返回长度值。
【解题思路】
老师上课讲的经典的一道动态规划。而且有两种方法:O(n2)和O(nlogn)。
(1)方法1:常规思路,O(n2)
f[i]:表示以元素a[i]为结尾的最长递增子序列的长度。
当数组为空时,返回0;
当只有一个元素时,返回1;
f[0]=1;
(以a[i]结尾:代表a[i]一定在这个子序列里面。如何用之前的f值得到f[i]呢?)
要想a[i]在子序列里面,那么必须由满足这样条件(j<i且a[j]<a[i])的f[j]来推导出f[i]。f[j]表示以元素a[j]为结尾的最长递增子序列的长度。因为在位置i前面满足a[j]<a[i]的j不一定唯一,我们要找到用j开始遍历的过程中,使得f值最大的某个j,即为最终可以推导出f[i]的f[j]。
∴f[i]=max{ f[j],其中j<i && a[j]<a[i] } + 1
答案:max{ f[i] } !!记住答案不一定是f[n]的
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if(nums.size() <= 1){
return nums.size();
}
vector<int> f; //f里面的值一定是非负整数
f.push_back(1); //即f[0]=1
for(int i=1; i<nums.size(); i++){
int max_fj = 0; //每次计算下一个元素的f值,就要重新开始寻找max_f[j]
//不能把nums[j]<nums[i]写在for循环的条件中,不然根本不能遍历到所有<i的元素
for(int j=0; j<i; j++){
if(nums[j]<nums[i] && max_fj < f[j]){
max_fj = f[j]; //选择符合条件且f值更大的
}
}
f.push_back(max_fj + 1);
}
sort(f.begin(), f.end());
return f[f.size() - 1];
}
};
(2)方法2:取决于第二层循环,仍然不是最快的。
数组f[i]:表示长度为i+1的最长递增子序列的最小末尾数,这样答案就是f.size()。
Eg1. [10, 9, 2, 5, 3, 7, 101, 18]
for i: 0→n-1
i=0时,f={10}——f[0]长度为1的所有递增序列中的最小的末尾数
i=1时,∵9<10,比10大的肯定会比9大,∴应该把9放进来,而把10覆盖。f={9}
i=2时,∵2<9,比9大的肯定会比2大,∴应该把2放进来,而把9覆盖。f={2}
i=3时,∵5>=2,f数组并没有变化 ∴把5添加进来。f={2, 5}——f[1]=5是长度为2所有递增序列中的最小的末尾数
i=4时,∵3>=2,遍历f的指针往下移动,
∵3<5,比5大的肯定会比3大,∴应该把3放进来,而把5覆盖。f={2, 3}
i=5时,∵7>=2,遍历f的指针往下移动,
∵7>=3,f数组并没有变化 ∴把7添加进来。f={2, 3, 7}
i=6时,..... f={2, 3, 7, 101}
i=7时,∵18>=2,遍历f的指针往下移动,
∵18>=3,遍历f的指针往下移动,
∵18>=7,遍历f的指针往下移动,
∵18<101,∴f={2, 3, 7, 18}
Eg2. [2,3,4,5,1,2,3]
f={2}→f={2,3}→f={2,3,4}→f={2,3,4,5}→f={1,3,4,5}→f={1,2,4,5}→f={1,2,3,5}
可以看出:f并不是存放要求的递增子序列。
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if(nums.size() <= 1){
return nums.size();
}
vector<int> f; //表示长度为i+1的最长递增子序列的最小末尾数
f.push_back(nums[0]);
for(int i=1; i<nums.size(); i++){
bool ischanged=false;
for(int j=0; j<f.size(); j++){
if(nums[i] <= f[j]){
f[j] = nums[i];
ischanged = true;
break;
}
}
if(!ischanged){
f.push_back(nums[i]);
}
}
return f.size();
}
};
(3)方法3:O(nlogn)
基于方法2改进,对于每一个元素nums[i],在f中找到第一个比它大的数所在的位置pos,并用它替换f[pos]。因为f是有序的,用二分查找最快为O(logn),所以总的复杂度为O(nlogn)。