LeetCode JAVA解题---300. 最长上升子序列

LeetCode 题库 全 JAVA 解题

300. 最长上升子序列

原题回顾：

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

示例 1:

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

说明：

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

思路

参考官方题解
有两种方法，下面我将按我理解的简单描述一下

方法一：动态规划

定义 dp[i] 为考虑前 i 个元素，以第 i个数字结尾的最长上升子序列的长度，注意nums[i] 必须被选取。
我们从小到大计算 dp[] 数组的值，在计算 dp[i] 之前，我们已经计算出 dp[0…i−1]的值，则状态转移方程为：
$dp[i]=max(dp[j])+num[i]$,其中$0<=j<i$ 且$num[j]<num[i]$
最后，整个数组的最长上升子序列即所有 dp[i] 中的最大值。
换种方法理解就是dp[i]所表示的就是以num[i]作为末尾元素的最长上升子序列
举个例子

输入：[10,9,2,5,3,7,101,18,4]
dp[0]:1
序列：10
dp[1]:1
序列：9
dp[2]:1
序列：2
dp[3]:2
序列：2 5
dp[4]:2
序列：2 3
dp[5]:3
序列：2 3 7
dp[6]:4
序列：2 3 7 101
dp[7]:4
序列：2 3 7 18
dp[8]:3
序列:2 3 4
所以max-dp[i]=4

方法二：贪心 + 二分查找

考虑一个简单的贪心，如果我们要使上升子序列尽可能的长，则我们需要让序列上升得尽可能慢，因此我们希望每次在上升子序列最后加上的那个数尽可能的小。
设当前已求出的最长上升子序列的长度为 len（初始时为 1），从前往后遍历数组 nums，在遍历到 nums[i] 时：

• 如果 nums[i]>d[len]，则直接加入到 d数组末尾，并更新 len=len+1
• 否则，在 d数组中二分查找，找到第一个比 nums[i] 小的数 d[k] ，并更新 d[k+1]=nums[i]。后面的数不变

举例：

输入： 1 　3 　6 　4　10 　5　6
依次插入：
ｄ＝［１］
ｄ＝［１　３］
ｄ＝［１　３　６］
ｄ＝［１　３　４］
ｄ＝［１　３　４　１０］
ｄ＝［１　３　４　５］
ｄ＝［１　３　４　５　６］
最后结果为ｌｅｎ（ｄ）＝５

代码（评论区）

方法一：

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

效果：

方法二：

class Solution {
    public int lengthOfLIS(int[] nums) {
        int len=1;
        int n=nums.length;
        if (n==0){
            return 0;
        }
        int[] d=new int[n+1];
        d[len]=nums[0];
        for (int i=1;i<n;++i){
            if(nums[i]>d[len]){
                d[++len]=nums[i];
            }else{
                int l=1,r=len,pos=0;
                while(l<=r){
                    int mid=(l+r)/2;
                    if (d[mid] < nums[i]) {
                        pos = mid;
                        l = mid + 1;
                    }else r = mid - 1;
                }
                d[pos + 1] = nums[i];
            }
        }
         return len;
    }
}

效果