LeetCode-【动态规划】-最长上升子序列

给定一个无序的整数数组，找到其中最长上升子序列的长度。

示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4 
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

说明:

• 可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
• 你算法的时间复杂度应该为 O(n2) 。

进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?

题解：本题很容易想到思路，一种是双侧循环嵌套，直接比较从第i个位置往前的上升子序列的长度，通过不断比较得到最长的上升子序列，另一种是动态规划解决，用dp[i]记录在位置i的最长子序列长度，也是不断比较最后得到最长子序列。but，这两种实现的算法复杂度都是O(n2) 。这对喜欢追求极致的我来说并不是满意的答案，那还有什么其他更好的解法呢？反正我是想不出来，所以只好问度娘了。。。结果真找到了一个，此算法登峰造极，写的很完美，参考链接：https://www.cnblogs.com/GodA/p/5180560.html。

动规解法：

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

基于二分查找的解法：

class Solution {
    public static int put(int[] b,int l,int r,int key){
        int mid;
        if(b[r]<key)
            return r+1;
        while(l<r){
            mid=l+(r-l)/2;
            if(b[mid]<key)
                l=mid+1;
            else
                r=mid;
        }
        return l;
    }
    public int lengthOfLIS(int[] nums) {
        int n=nums.length;
        if(n==0)
            return 0;
        int[] b=new int[n+1];
        int max=1;
        b[1]=nums[0];
        for(int i=1;i<n;i++){
            int next=put(b,1,max,nums[i]);
            b[next]=nums[i];
            max=Math.max(max,next);
        }
        return max;
    }
}