多味的LeetCode --- 300. 最长上升子序列-优快云博客

本文详细解析了如何求解最长上升子序列问题，通过两种方法：遍历与动态规划，展示了具体的实现代码，并对比了各自的优缺点。适用于算法学习者和面试准备者。

题目描述：

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

输入: [10,9,2,5,3,7,101,18]
输出: 4

解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

解题思路1:

依次遍历，引入一个变量，按照依次递增的顺序取。

代码1：

此代码还有一种情况无法处理：[10, 9, 2, 5, 3, 4, 7, 101, 18]

class Solution(object):
    def lengthOfLIS(self, nums):

        if len(nums) == 1:
            return 1
        arr = []
        max_length = 0
        for i in range(len(nums)-1):
            juzhen = []
            max1 = nums[i]
            for j in range(i+1, len(nums)):
                if max1 < nums[j]:
                    juzhen.append(max1)
                    max1 = nums[j]
            juzhen.append(max1)

            if len(juzhen) > max_length:
                arr = juzhen
                max_length = len(juzhen)

        return arr
s = Solution()
nums = [10, 9, 2, 5, 3, 7, 101, 18]
print(s.lengthOfLIS(nums))

解题思路2: 动态规划

将 $d p [i]$ 所有元素置 1，含义是每个元素都至少可以单独成为子序列，此时长度都为 1。
依次判断当前元素与之前元素的大小关系，将最大值进行累加。

代码2：

Python写法：

class Solution:
    def lengthOfLIS(self, nums):
        if not nums: return 0
        dp = [1] * len(nums)
        for i in range(len(nums)):
            for j in range(i):
                if nums[j] < nums[i]: # 如果要求非严格递增，将此行 '<' 改为 '<=' 即可。
                    dp[i] = max(dp[i], dp[j] + 1)
        return max(dp)
        
s = Solution()
nums = [1, 3, 6, 7, 9, 4, 10, 5, 6]
print(s.lengthOfLIS(nums))

C++写法：

以第 $j$ 个数为倒数第二个数的子序列长度的最大值 $f [j]$ ，则总长度为 $f [j] + 1$

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        vector<int> f(n);
        for(int i = 0; i < n; i++){
            f[i] = 1;
            for(int j = 0; j < i; j++){
                if (nums[j] < nums[i])
                    f[i] = max(f[i], f[j] + 1);
            }
        }
        int res = 0;
        for(int i = 0; i < n; i++){
            res = max(res, f[i]);
        }
        return res;
    }
};