【LeetCode】300.Longest Increasing Subsequence最长递增子序列LIS

给定数组 [10, 9, 2, 5, 3, 7, 101, 18]，其中一个最长递增子序列（不需要连续）为[2, 3, 7, 101] ，length为4。因为最长子序列不一定唯一，所以我们只需要返回长度值。
【解题思路】
老师上课讲的经典的一道动态规划。而且有两种方法：O(n²)和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)。