Leetcode300 -- 最长上升子序列

题目描述

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

示例:

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

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

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

class Solution {
     public int lengthOfLIS(int[] nums) {
        int len = nums.length;
        if (len <= 1){
            return len;
        }
        int[] dp = new int[len];
        dp[0] = 1;
        // 这个题是有些小细节的 dp[i] 代表以i结尾的最长子序列的长度 所以在最后返回的时候并没有返回dp[len - 1],而是要在dp数组中选取一个最大值
        for (int i = 1;i < len;i++){
            int tmp = 1;
            // 对于每一个i 都要遍历j,范围是[0,i -1] 然后取最大值
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]){
                    if (dp[j] + 1 > tmp){
                        tmp = dp[j] + 1;
                    }
                }
            }
            dp[i] = tmp;
        }
        int res = 1;
        for (int i = 0; i < len; i++) {
            if (dp[i] > res){
                res = dp[i];
            }
        }
        return res;
    }
}

进阶的做法：

转载力扣大神的题解

修改状态定义（同时用到了贪心算法、二分查找）

依然是着眼于一个上升子序列的结尾的元素；

如果已经得到的上升子序列的结尾的数越小，遍历的时候后面接上一个数，就会有更大的可能性构成一个更长的上升子序列；

既然结尾越小越好，我们可以记录在长度固定的情况下，结尾最小的那个元素的数值，这样定义也是为了方便得到「状态转移方程」。

为了与之前的状态区分，这里将状态数组命名为 tail。

第 1 步：定义新状态（特别重要）

tail[i] 表示长度为 i + 1 的所有上升子序列的结尾的最小值。

说明：tail[0] 表示长度为 1的所有上升子序列中，结尾最小的那个元素的数值，以题目中的示例为例 [10, 9, 2, 5, 3, 7, 101, 18] 中，容易发现长度为 2 的所有上升子序列中，结尾最小的是子序列 [2, 3] ，因此 tail[1] = 3

下标和长度有一个 1 的偏差；状态定义其实也描述了状态转移方程。

第 2 步：思考状态转移方程

从直觉上看，数组 tail 也是一个严格上升数组。

1、设置一个数组 tail，初始时为空；

注意：数组 tail 虽然是有序数组，但它不是问题中的「最长上升子序列」（下文还会强调），不能命名为 LIS。有序数组 tail 只是用于求解 LIS 问题的辅助数组。

2、在遍历数组 nums 的过程中，每来一个新数 num，如果这个数严格大于有序数组 tail 的最后一个元素，就把 num 放在有序数组 tail 的后面，否则进入第 3 点；

注意：这里的大于是「严格大于」，不包括等于的情况。

3、在有序数组 tail 中查找第 1 个等于大于 num 的那个数，试图让它变小；

如果有序数组 tail 中存在等于 num 的元素，什么都不做，因为以 num 结尾的最短的「上升子序列」已经存在；

如果有序数组 tail 中存在大于 num 的元素，找到第 1 个，让它变小，这样我们就找到了一个结尾更小的相同长度的上升子序列。

说明：我们再看一下数组 tail[i] 的定义：长度为 i + 1 的所有最长上升子序列的结尾的最小值。因此，在遍历的过程中，我们试图让一个大的值变小是合理的。

这一步可以认为是「贪心算法」，总是做出在当前看来最好的选择，当前「最好的选择」是：当前只让让第 1 个严格大于 nums[i] 的数变小，变成 nums[i]，这一步操作是“无后效性”的。

由于是在有序数组中的操作，因此可以使用「二分查找算法」。

4、遍历新的数 num ，先尝试上述第 2 点，第 2 点行不通则执行第 3 点，直到遍历完整个数组 nums，最终有序数组 tail 的长度，就是所求的“最长上升子序列”的长度。

第 3 步：思考初始化

dp[0] = nums[0]，在只有 1 个元素的情况下，它当然是长度为 1 并且结尾最小的元素。

第 4 步：思考输出

数组 tail 的长度，上文其实也已经说了，还是依据定义，tail[i] 表示长度固定为 i + 1 的所有「上升子序列」的结尾元素中最小的那个，长度最多就是数组 tail 的长度。

第 5 步：思考状态压缩

无法压缩。

class Solution {
     public int lengthOfLIS(int[] nums) {
        /*
        tail[i] 长度为i + 1 的子序列最小的结尾值
         */
        int len = nums.length;
        if (len < 2){
            return len;
        }
        int[] tail = new int[len];
        tail[0] = nums[0];//初始状态
        int end = 0;//当前的最大长度进行到哪里了 也就是tail数组赋值到哪里了
        for (int i = 1; i < len; i++) {
            if (nums[i] > tail[end]){ //当前元素大于tail末尾元素 直接增加一个元素
                end++;
                tail[end] = nums[i];
            }else{ //在前边找第一个大于它的 替换 -- 查找用二分
                int left = 0;
                int right = end;
                while (left < right){
                    int mid = left + (right - left)/2;
                    if (tail[mid] < nums[i]){
                        left = mid + 1;
                    }else{
                        right = mid;
                    }
                }
                tail[left] = nums[i];
            }
        }
        return end + 1;
    }
}