LeetCode——0300.最长递增子序列

300.最长递增子序列

题目

给你一个整数数组 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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-increasing-subsequence
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解思路

1>源代码

# dp
class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        lens = len(nums)
        dp = [1] * lens
        for i in range(lens):
            for j in range(i):
                if(nums[j] < nums[i]):
                    dp[i] = max(dp[i], 1+dp[j])
        return max(dp)


# 贪心+二分
class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        d = []
        for n in nums:
            if not d or n > d[-1]:
                d.append(n)
            else:
                l, r = 0, len(d) - 1
                loc = r
                while l <= r:
                    mid = (l + r) // 2
                    if d[mid] >= n:
                        loc = mid
                        r = mid - 1
                    else:
                        l = mid + 1
                d[loc] = n
        return len(d)

# 作者：LeetCode-Solution
# 链接：https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/zui-chang-shang-sheng-zi-xu-lie-by-leetcode-soluti/
# 来源：力扣（LeetCode）
# 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2>算法介绍

本题比较容易想到动态规划的方法，即维护一个数组dp[]，其中dp[i]的值表示nums[0:i]这个子序列的最大递增子序列长(说起来有点绕口)，dp[i]的初值应为1，因为即使整个序列倒序，最大子序列的长也应为1，即只含有一个元素。

对于nums[i]来说，对该元素左边的元素进行遍历。如果当前遍历的元素值nums[j]小于nums[i]，则说明可以构造新的递增子序列，则dp[i] = dp[j] + 1。最终dp[i]的值应为所有遍历得到的最大值，所以代码如下：

            for j in range(i):
                if(nums[j] < nums[i]):
                    dp[i] = max(dp[i], 1+dp[j])

动态规划的方法比较直观，但是其时间复杂度为O(n^2)，性能并不优秀。题解当中还给出了另一种解法，利用的是贪心算法+二分查找。

---

由于我们想要找到最长递增子序列，那么我们就希望递增的幅度越小越好。也就是说，[1,2]和[1,3]这两种递增子序列我们自然希望留下[1,2]。

基于以上思路，代码维护了一个列表d[i]，表示长度为 i 的最长上升子序列的末尾元素的最小值，用len记录目前最长上升子序列的长度，初始情况下d[1] = nums[0]。

我们依次遍历数组nums[]中的每个元素，并更新数组d[]和len的值。如果nums[i]>d[len] 则更新 len = len + 1，否则在 d[1…len]中找满足d[i−1]<nums[j]<d[i] 的下标i，并更新d[i] = d[i]=nums[j]。

到这一步为止，相信接触过贪心算法的都能看明白，我在思考的时候也想到过用贪心算法，但他的下一步简直是惊天一笔。由于我们要找满足d[i−1]<nums[j]<d[i] 的下标i，并且d[]数组始终是有序的，那么我们就可以采用二分查找的方法来降低时间复杂度。说实话，理论我都懂，但是用二分查找法去寻找 **第一个比nums[i] 小的数 d[k] ** ，我是真的没什么头绪。代码却用一个loc指针就完美完成了这项任务，实在是让我惊叹。