LeetCode-300.最长递增子序列

暴力解法

最暴力的解法就是用 dp[i]来存储以下标为 i 的数为结尾的最大子序列长度，然后使用两层循环求解该问题，具体代码如下：

class Solution {
    public:
        int lengthOfLIS(vector<int>& nums) {
            int n = nums.size();
            vector<int> dp(n, 1);
            for(int i = 0; i < n; i++) {
                for(int j = 0; j < i; j++) {
                    if(nums[j] < nums[i]) {
                         dp[i] = max(dp[i], dp[j] + 1);
                    }
                 }
             }
             int res = 0;
             for(int i = 0; i < n; i++) {
                 res = max(res, dp[i]);
             }
             return res;
        }
};

贪心+二分查找

考虑贪心的策略，若要使上升子序列尽可能地长，则需要让子序列的上身速度尽可能地慢，因此我们每次要在子序列后面加上一个尽可能小的数，这样才能让我们的上升子序列尽可能地长。

根据上述的贪心策略，重新定义状态 dp。dp[i]表示长度为 i 的最长上升子序列末尾的最小值。

根据上述的定义，可以得出，dp[i]关于 i 单调递增的。若 i < j，且 dp[i] > dp[j]，则必然可以从以 dp[j]为结尾的最长上升子序列的末尾删除 j - i 个数，得到长度为 i，结尾为 x 的上升子序列。由 x < dp[j] < dp[i]可以推出矛盾，故 dp[i]关于 i 单调递增。

由 dp[i]关于 i 单调递增的性质，便可以使用二分查找的策略，找到末尾小于当前数的最长子序列，将整体的时间复杂度降为 O(nlogn)。具体代码如下：

class Solution {
    public:
        int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        if(n == 0) return 0;
        vector<int> dp(n + 1, 0);
        int len = 0;
        dp[0] = INT_MIN;
        dp[++len] = nums[0];
        for(int i = 1; i < n; i++) {
            if(nums[i] > dp[len]) {
                dp[++len] = nums[i];
            }
            else {
                int l = 0, r = len;
                while(l < r) {
                    int mid = (l + r + 1) >> 1;
                    if(dp[mid] < nums[i]) {
                        l = mid;
                    }
                    else {
                        r = mid - 1;
                    }
                 }
                 len = max(len, r + 1);
                 // dp[r] < nums[i] <= dp[r+1]
                 dp[r + 1] = nums[i];
            }
       }
       return len;
   }
}