2026.03.23 最长递增子序列 & 最长连续递增序列 & 最长公共子序列

对于不要求连续的子序列，dp代表的都是以nums[i]结尾的最长值

python 复制代码

# dp解法
class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        n = len(nums)
        # dp[i]代表以nums[i]为结尾的最长子序列
        dp = [1] * n
        res = 1

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

        return res

贪心 + 二分优化：

思路：维护一个数组group，group[i]代表长度i的子序列的结尾，迭代时外层循环0-n，内层循环j替换，找到第一个大于等于它的。

python 复制代码

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        self.n = len(nums)
        self.tails = [nums[0]]

        def find_replace(num:int):
            left = -1
            right = len(self.tails)
            while left != right - 1:
                mid = (left + right) >> 1
                if num <= self.tails[mid]:
                    right = mid
                else:
                    left = mid
                
            self.tails[right] = num

        for i in range(1, self.n):
            if nums[i] > self.tails[-1]:
                self.tails.append(nums[i])
            else:
                find_replace(nums[i])
        
        return len(self.tails)

674. 最长连续递增序列

python 复制代码

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        n = len(nums)
        right = 0
        res = 1
        cur = 1
        while right != n - 1:
            right += 1
            if nums[right] > nums[right - 1]:
                cur += 1
                res = max(res, cur)
            else:
                cur = 1
        return res

718. 最长重复子数组

python 复制代码

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        n, m = len(nums1), len(nums2)
        # dp[i][j]代表nums1的前i个字符和nums2的前j个字符的最大子数组长度
        dp = [[0] * (m + 1) for _ in range(n + 1)]
        res = 0
        
        for i in range(1, n + 1):
            for j in range(1, m + 1):
                if nums1[i - 1] == nums2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                    res = max(res, dp[i][j])
        
        return res

1143. 最长公共子序列

python 复制代码

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        n, m = len(text1), len(text2)
        # dp[i][j]代表text1的前i个字符和text2的前i个字符的最长公共子序列
        dp = [[0] * (m + 1) for _ in range(n + 1)]

        for i in range(1, n + 1):
            for j in range(1, m + 1):
                if text1[i - 1] == text2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
        
        return dp[n][m]