LeetCode-300-最长递增子序列

LeetCode-300-最长递增子序列

思路

1.动态规划：O(n*n)
题目要求找出的是递增子序列，子序列不一定是连续的，但是要保证递增，因此可以用动态规划来维护一个不断更新的dp数组，该数组表示，以当前元素为最后一个元素的子序列的最大长度

2.贪心+二分查找：O(nlogn)
遍历数组，然后维护一个tail[]数组，tail数组必须是严格递增的
当nums[i]>tail[len]时，tail[len+1]=nums[i]，tail数组长度加1
当nums[i]<=tail[len]时，通过二分查找，把nums[i]替换tail数组中合适的元素

如序列 1,101,102,2,3,4,999
原数组每次遍历输出的tails为:
1
1,101
1,101,102
1,2,102
1,2,3
1,2,3,4
1,2,3,4,999

可能会担心这个替换会导致子序列不成立，但是其实tail数组所产生的序列并不一定是最长的递增子序列，我们所需要的只是它的长度，因为每次长度变化都是表示遍历到当前位置时的最大长度，我们已经得到这个长度了，前面的元素发生替换并不会产生影响，反而是推动了找到最长递增子序列
参考下列例子

如序列 1,4,3,13,2,5
1
1,4
1,3
1,3,13
1,2,13
1,2,5
可见，元素替换并不会导致不好的影响

代码

//1.动态规划：O(n*n)
class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums==null||nums.length==0)return 0;
        int []dp=new int[nums.length];
        int res=1;
        for(int i=0;i<nums.length;i++){
            dp[i]=1;//至少为1，表示自己
            for(int j=0;j<i;j++){
                if(nums[j]<nums[i]){
                    dp[i]=Math.max(dp[i],dp[j]+1);//更新dp[i]
                }
            }
            res=Math.max(dp[i],res);//更新最大值
        }
        return res;
    }
}

//2.贪心+二分查找：O(nlogn)
class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums==null||nums.length==0)return 0;
        int len=1,n=nums.length;
        int []tail=new int[n+1];
        tail[len]=nums[0];
        for(int i=1;i<n;i++){
            if(nums[i]>tail[len]){
                tail[++len]=nums[i];
            }
            else{
                //二分查找位置
                int l=1,r=len,pos=0;
                while(l<=r){
                    int mid=l+(r-l)/2;
                    if(tail[mid]<nums[i]){
                        pos=mid;
                        l=mid+1;
                    }
                    else{
                        r=mid-1;
                    }
                }
                tail[pos+1]=nums[i];
            }
        }

        return len;
    }
}