LeetCode300 最长上升子序列

题目

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

 示例 1： 
输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

 示例 2： 
输入：nums = [0,1,0,3,2,3]
输出：4

 示例 3： 
输入：nums = [7,7,7,7,7,7,7]
输出：1

 提示： 
 1 <= nums.length <= 2500 
 -10⁴ <= nums[i] <= 10⁴

 进阶： 
 你可以设计时间复杂度为 O(n²) 的解决方案吗？ 
 你能将算法的时间复杂度降低到 O(n log(n)) 吗? 

方法

动态规划法

题目是求最值并且能分解成子问题，可以采用动态规划的方法解答
状态方程dp[i]表示选中第i个数字能组成的最大增序列个数, 当遍历到第i个数时，再遍历之前的所有数，找出最大的dp[j]，此时dp[i] = max(dp[j])+1，0<=j<i，0<=i<length

• 时间复杂度：O（n^2）
• 空间复杂度：O（n）

Java版本

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

JavaScript版本

/**
 * @param {number[]} nums
 * @return {number}
 */
var lengthOfLIS = function(nums) {
    let max = 0;
    const dp = new Array(nums.length);
    for(let i=0;i<nums.length;i++){
        dp[i] = 1;
        for(let j=0;j<i;j++){
            if(nums[i]>nums[j]){
                dp[i] = Math.max(dp[i],dp[j]+1);
            }
        }
        max = Math.max(max,dp[i]);
    }
    return max;
};

贪心+二分查找

设置dp数组用于存储最小值列表，即dp[i]表示长度为i的最长子序列的末尾最小值，并用maxLen表示当前最长子序列的末尾最小值，
如果num[i]>dp[maxLen]，则说明最长子序列可以增加，则dp数组加入num[i]并更新长度maxLen
如果num[i]<=dp[maxLen]，则说明长度不变，但需要更新小于maxLen长度的dp数组，由于dp数组具有单调递增性，因此可用二分法找到num[i]的位置插入dp中
证明dp数组的单调递增性：
因为如果d[j]≥d[i] 且 j<i，我们考虑从长度为 i 的最长上升子序列的末尾删除i−j 个元素，那么这个序列长度变为 j ，且第 j 个元素 x（末尾元素）必然小于 d[i]，也就小于 d[j]。那么我们就找到了一个长度为 j 的最长上升子序列，并且末尾元素比 d[j] 小，从而产生了矛盾。因此数组 dp 的单调性得证。

• 时间复杂度：O（nlogn），n为数组长度
• 空间复杂度：O（n）

Java版本

class Solution { 
    public int lengthOfLIS(int[] nums) {
        int length = nums.length;
        if(length==0) return 0;
        int[] dp = new int[length+1]; //dp[i]表示长度为i的最长子序列的末尾最小值
        dp[1] = nums[0];
        int maxLen = 1;
        for(int i=1;i<length;i++){
            if(nums[i]>dp[maxLen]){
                maxLen++;
                dp[maxLen] = nums[i];
            }else{
                int l = 1,r = maxLen,pos = 0;
                while(l<=r){
                    int mid = (l+r)/2;
                    if(dp[mid]<nums[i]){  //判断小于而不是大于的原因是需要保存最小值，如果取大于，则num[i]将会替代之前的较小值，留下最大值
                        pos = mid;
                        l = mid+1;
                    }else{
                        r = mid-1;
                    }
                }
                dp[pos+1] = nums[i];
            }
        }
        return maxLen;
    }
}

JavaScript版本

/**
 * @param {number[]} nums
 * @return {number}
 */
var lengthOfLIS = function(nums) {
    const dp = new Array(nums.length+1);
    dp[1] = nums[0];
    let max = 1;
    for(let i=1;i<nums.length;i++){
        if(nums[i]>dp[max]){
            max++;
            dp[max] = nums[i];
        }else{
            let l = 1,r = max,pos = 0;
            while(l<=r){
                let mid = parseInt((l+r)/2);
                if(dp[mid]<nums[i]){
                    l = mid+1;
                    pos = mid;
                }else{
                    r = mid-1;
                }
            }
            dp[pos+1] = nums[i];
        }
    }
    return max;
};