最长递增子序列，力扣

题目地址：

300. 最长递增子序列 - 力扣（LeetCode）

难度：中等

今天刷，大家有兴趣可以点上面链接，看看题目要求，试着做一下。

题目：

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

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

我们直接看题解吧：

快速理解解题思路小建议：

可以先简单看一下解题思路，然后照着代码看思路，会更容易理解一些。

审题目+事例+提示：

严格递增  即连续递增

解题方法：

方法一是  动态规划

方法二是  动态规划+二分法

解题方法分析：

 解法一中，遍历计算 dp列表需 O(N)，计算每个 dp[k] 需 O(N)。动态规划中，通过线性遍历来计算 dp的复杂度无法降低，每轮计算中，需要通过线性遍历 [0,k)区间元素来得到 dp[k] 。

因此，可以通过重新设计状态定义，使整个 dp为一个排序列表，这样在计算每个 dp[k] 时，就可以通过二分法遍历 [0,k)区间元素，将此部分复杂度由 O(N)降至 O(logN)。

解题分析：

新的状态定义：
       我们考虑维护一个列表 tails，其中每个元素 tails[k] 的值代表 长度为 k+1的子序列尾部元素的值。如 [1,4,6]序列，长度为 1,2,3的子序列尾部元素值分别为 tails=[1,4,6]。

状态转移设计：
设常量数字 N，和随机数字 x，我们可以容易推出：当 N 越小时，N<x 的几率越大。

例如： N=0肯定比 N=1000更可能满足 N<x。
        在遍历计算每个 tails[k]，不断更新长度为 [1,k] 的子序列尾部元素值，始终保持每个尾部元素值最小 （例如 [1,5,3]， 遍历到元素 5时，长度为 2的子序列尾部元素值为 5；当遍历到元素 3时，尾部元素值应更新至 3，因为 3 遇到比它大的数字的几率更大）。tails列表一定是严格递增的： 即当尽可能使每个子序列尾部元素值最小的前提下，子序列越长，其序列尾部元素值一定更大。

反证法证明： 当 k<i，若 tails[k]>=tails[i]，代表较短子序列的尾部元素的值 >较长子序列的尾部元素的值。这是不可能的，因为从长度为 i的子序列尾部倒序删除 i−1个元素，剩下的为长度为 k 的子序列，设此序列尾部元素值为 v，则一定有 v<tails[i] （即长度为 k 的子序列尾部元素值一定更小）， 这和 tails[k]>=tails[i]矛盾。
既然严格递增，每轮计算 tails[k]时就可以使用二分法查找需要更新的尾部元素值的对应索引 i。

解题思路：

1、状态定义： tails[k]的值代表 长度为 k+1子序列 的尾部元素值。
 

2、转移方程： 设 res为 tails 当前长度，代表直到当前的最长上升子序列长度。

设 j∈[0,res)，考虑每轮遍历 nums[k]时，通过二分法遍历 [0,res)列表区间，找出 nums[k]的大小分界点，会出现两种情况：

    · 区间中存在 tails[i]>nums[k]： 将第一个满足 tails[i]>nums[k] 执行 tails[i]=nums[k] ；因为更小的 nums[k] 后更可能接一个比它大的数字（前面分析过）。
    · 区间中不存在 tails[i]>nums[k] ： 意味着 nums[k] 可以接在前面所有长度的子序列之后，因此肯定是接到最长的后面（长度为 res ），新子序列长度为 res+1。

3、初始状态：令 tails列表所有值 =0。
4、返回值： 返回 res ，即最长上升子子序列长度。

代码实现(方法二)：

// Dynamic programming + Dichotomy.
class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] tails = new int[nums.length];
        int res = 0;
        for(int num : nums) {
            int i = 0, j = res;
            while(i < j) {
                int m = (i + j) / 2;
                if(tails[m] < num) i = m + 1;
                else j = m;
            }
            tails[i] = num;
            if(res == j) res++;
        }
        return res;
    }
}

代码实现(方法一)： 

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