leetcode300. 最长递增子序列

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/longest-increasing-subsequence

题目描述

给你一个整数数组 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
-104 <= nums[i] <= 104

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

解题思路

我们设计动态规划算法，不是需要一个 dp 数组吗？我们可以假设 dp[0…i-1] 都已经被算出来了，然后问自己：怎么通过这些结果算出 dp[i]？
根据题目的定义,我们很容易得出base case dp[i] = 1;任何位置本身的长度可以先初始化为1.
我们再看怎么求出具体值,用图来演示:
在这里插入图片描述
知道dp[3] = 3,时,怎么求dp[4] 呢,4 位置的数字从0 位置开始比较到3位置,
如果4位置的数字比3位置的数字大,那么dp[4] = 1 + dp[3];
知道这个过程我们就可以写出dp算法了.

代码演示:

	/**
	*  最长递增子序列 可以直接复制进力扣测试
	*/
   int lengthOfLIS(int[] nums) {
       int N = nums.length;
       //动态规划表
       int[]dp = new int[N];
       for(int i = 0; i < N; i++){
       //base case 每个位置本身长度
           dp[i] = 1;
           for(int j = 0;j < i; j++){
           // i 位置依次向前比 ,比j 位置大,就是 1 + dp[i]
           // 根据不同j位置上的数,来更新最大值
               if(nums[i] > nums[j]){
                  dp[i] = Math.max(dp[i],1 + dp[j]);  
               }
               
           }
       }
       int res = 0;
       //取出 dp表中的最大值 就是我们要的答案.
       for (int i = 0; i < dp.length;i++){
           res = Math.max(res,dp[i]);
       }
       return res;
    }

二分法改进(N * logN)

	/**
	*  最长递增子序列 可以直接复制进力扣测试
	*/
   int lengthOfLIS(int[] nums) {
        int N = nums.length;
        int[] ends = new int[N];
        int pies = 0;
        for(int i = 0 ; i < nums.length;i++){
            int cur = nums[i];
            int L = 0;
            int R = pies;
            while(L < R){
                int mid = (L + R) / 2;
                if(ends[mid] >= cur){
                    R = mid;
                }else{
                    L = mid + 1;
                }
            }

            if(L == pies){
                pies++;
            }
            ends[L] = cur;
        }

        return pies;
    }