leetcode_300 最长递增子序列

1、题目描述

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

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

2、解题思路

         动态规划：时间复杂度O(n*n),空间复杂度O(n)；

        贪心+二分查找：时间复杂度，空间复杂度O(n)；

3、具体方法分析

3.1、动态规划求解

        题目要求找到数组中严格递增的最大子序列长度，dp三部曲如下：

        dp[i]:

         表示考虑前i个元素，以第i个下标对应元素结尾的数组范围内最长递增子序列的长度，我们从小到大计算dp数组的值，在计算dp[i]之前，dp[0,1,2,,,,,,,i-1]的值已经计算出来了；

        状态转移方程：

   

         初始化：

        最开始的dp输出全都初始化为1，因为每一个数字单独本身的最长子序列为1.

        最后，整个数组的最长上升子序列即所有 dp[i] 中的最大值，因为dp[i]存储的是每一个下标i结尾的前i个元素构成的最长递增子序列长度值，换句话说也就是每一个i都有一个对应的最长子序列长度值，然后我们从这些长度值中选出最长的作为整个Nums数组的最长递增子序列长度，即：

        

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;
        
    }


}

      

 3.2、动态规划+二分查找

很具小巧思。新建数组 cell，用于保存最长上升子序列。

对原序列进行遍历，将每位元素二分插入 cell 中。

    如果 cell 中元素都比它小，将它插到最后
    否则，用它覆盖掉比它大的元素中最小的那个。

总之，思想就是让 cell 中存储比较小的元素。这样，cell 未必是真实的最长上升子序列，但长度是对的。

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;

    }
}

代码2：

public class Solution {
    public int lengthOfLIS(int[] nums) {
        int len = nums.length;
        if (len <= 1) {
            return len;
        }

        // tail 数组的定义：长度为 i + 1 的上升子序列的末尾最小是几
        int[] tail = new int[len];
        // 遍历第 1 个数，直接放在有序数组 tail 的开头
        tail[0] = nums[0];
        // end 表示有序数组 tail 的最后一个已经赋值元素的索引
        int end = 0;

        for (int i = 1; i < len; i++) {
            // 【逻辑 1】比 tail 数组实际有效的末尾的那个元素还大
            if (nums[i] > tail[end]) {
                // 直接添加在那个元素的后面，所以 end 先加 1
                end++;
                tail[end] = nums[i];
            } else {
                // 使用二分查找法，在有序数组 tail 中
                // 找到第 1 个大于等于 nums[i] 的元素，尝试让那个元素更小
                int left = 0;
                int right = end;
                while (left < right) {
                    // 选左中位数不是偶然，而是有原因的，原因请见 LeetCode 第 35 题题解
                    // int mid = left + (right - left) / 2;
                    int mid = left + ((right - left) >>> 1);
                    if (tail[mid] < nums[i]) {
                        // 中位数肯定不是要找的数，把它写在分支的前面
                        left = mid + 1;
                    } else {
                        right = mid;
                    }
                }
                // 走到这里是因为 【逻辑 1】 的反面，因此一定能找到第 1 个大于等于 nums[i] 的元素
                // 因此，无需再单独判断
                tail[left] = nums[i];
            }
            // 调试方法
            // printArray(nums[i], tail);
        }
        // 此时 end 是有序数组 tail 最后一个元素的索引
        // 题目要求返回的是长度，因此 +1 后返回
        end++;
        return end;
    }

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