【LeetCode 刷题】动态规划(5)-子序列问题

此博客为《代码随想录》动态规划章节的学习笔记，主要内容为动态规划子序列问题的相关题目解析。

文章目录

不连续子序列

[300. 最长递增子序列](#300. 最长递增子序列)

[1143. 最长公共子序列](#1143. 最长公共子序列)

[1035. 不相交的线](#1035. 不相交的线)

连续子序列

[674. 最长连续递增序列](#674. 最长连续递增序列)

[718. 最长重复子数组](#718. 最长重复子数组)

[53. 最大子序和](#53. 最大子序和)

编辑距离

[392. 判断子序列](#392. 判断子序列)

[115. 不同的子序列](#115. 不同的子序列)

[583. 两个字符串的删除](#583. 两个字符串的删除)

[72. 编辑距离](#72. 编辑距离)

回文

[647. 回文子串](#647. 回文子串)

516.最长回文子序列

不连续子序列

300. 最长递增子序列

题目链接

python 复制代码

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

状态定义：dp[i] 表示以 num[i] 结尾的最长递增子序列的长度
递推公式：dp[i] = max(dp[i], dp[j] + 1)，dp[i] 可以由前面任意位置转移而来，取最大值

1143. 最长公共子序列

题目链接

python 复制代码

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m, n = len(text1), len(text2)
        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 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[m][n]

状态定义：dp[i][j] 表示考虑 text1 前 i 个字符、text2 前 j 个字符的最长公共子序列长度（不要求一定以 text1[i-1] 和 text2[j-1] 结尾）
递推公式：
- 当前字符相同时，dp[i][j] = dp[i-1][j-1] + 1（不考虑 dp[i-1][j] 和 dp[i][j-1]，肯定小于等于 dp[i-1][j-1] + 1）
- 当前字符不同时，dp[i][j] = max(dp[i-1][j], dp[i][j-1])

1035. 不相交的线

题目链接

python 复制代码

class Solution:
    def maxUncrossedLines(self, nums1: List[int], nums2: List[int]) -> int:
        m, n = len(nums1), len(nums2)
        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if nums1[i-1] == nums2[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[m][n]

与上题完全相同

连续子序列

674. 最长连续递增序列

题目链接

python 复制代码

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        n = len(nums)
        dp = [1 for _ in range(n)]
        res = 1
        for i in range(1, n):
            if nums[i] > nums[i-1]:
                dp[i] = dp[i-1] + 1
            res = max(res, dp[i])
        return res

与 "300. 最长递增子序列" 相比，此题要求子序列连续
递推公式：仅用考虑前一个元素
- 满足递增关系，dp[i] = dp[i-1] + 1
- 不满足递增关系，dp[i] = 1

718. 最长重复子数组

题目链接

python 复制代码

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        m, n = len(nums1), len(nums2)
        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
        res = 0
        for i in range(1, m + 1):
            for j in range(1, n + 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. 最长公共子序列" 相比，此题要求子序列连续
状态定义：dp[i][j] 表示以 nums1[i-1] 和 nums2[j-1] 结尾的数组之间的最长重复子数组长度（与 "1143. 最长公共子序列" 的状态定义不同）
递推公式
- 当前数字相等，dp[i][j] = dp[i-1][j-1] + 1
- 当前数字不相等，dp[i][j] = 0

53. 最大子序和

题目链接

python 复制代码

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        dp = [-inf for _ in range(n + 1)]
        res = -inf
        for i in range(1, n + 1):
            dp[i] = max(nums[i-1], dp[i-1] + nums[i-1])
            res = max(res, dp[i])
        return res

状态定义：dp[i] 表示以 num[i-1] 结尾的最大子序列和
递推公式：dp[i] = max(nums[i-1], dp[i-1] + nums[i-1])，不继承 / 继承之前的序列和
初始化：额外增加一个状态位，默认初始化为 -inf

编辑距离

392. 判断子序列

题目链接

python 复制代码

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        m, n = len(s), len(t)
        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if s[i-1] == t[j-1]:
                    dp[i][j] = dp[i-1][j-1] + 1
                else:
                    dp[i][j] = dp[i][j-1]
        return dp[m][n] == m

与 "1143. 最长公共子序列" 基本相同
递推公式：当元素不相等时，题目要判断 s 是否为 t 的子序列，因此 s 的元素不能缺失，故 dp[i][j] = max(dp[i-1][j], dp[i][j-1]) 可优化为 dp[i][j] = dp[i][j-1]
返回值：最长公共子序列是否与 s 的长度相同
另：双指针法更为简单

115. 不同的子序列

题目链接

python 复制代码

class Solution:
    def numDistinct(self, s: str, t: str) -> int:
        m, n = len(s), len(t)
        if m < n:
            return 0
        dp = [[1] + [0] * m for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if s[i-1] == t[j-1]:
                    dp[i][j] = dp[i-1][j] + dp[i-1][j-1]
                else:
                    dp[i][j] = dp[i-1][j]
        return dp[m][n]

状态定义：dp[i][j] 表示考虑 s 前 i 个字符、t 前 j 个字符，不同的子序列共有多少个
递推公式：
- 当元素相等时，s 可以删也可以不删，即 dp[i][j] = dp[i-1][j] + dp[i-1][j-1]
- 当元素不等时，s 必须要删除，即 dp[i][j] = dp[i-1][j]
初始化：第一列为 1 其余列为 0

583. 两个字符串的删除

题目链接

python 复制代码

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        m, n = len(word1), len(word2)
        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
        for i in range(m + 1): dp[i][0] = i
        for j in range(n + 1): dp[0][j] = j 
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if word1[i-1] == word2[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + 1
        return dp[m][n]

状态定义：dp[i][j] 表示考虑 s 前 i 个字符、t 前 j 个字符，最少删除字符数
递推公式：
- 当前字符相等时，不需要删除，dp[i][j] = dp[i-1][j-1]
- 当前字符不相等时，删除 s 或删除 t，dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + 1
初始化：第一行、第一列初始化为对应字符的数量，即删除 x 个字符后变成空字符串
另：本题还可通过求最长公共子序列，之后与二者长度相减，得到最少删除字符数

72. 编辑距离

题目链接

python 复制代码

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        m, n = len(word1), len(word2)
        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
        for i in range(m + 1): dp[i][0] = i
        for j in range(n + 1): dp[0][j] = j
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if word1[i-1] == word2[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1
        return dp[m][n]

在上题的基础上，额外添加了替换元素，在当前字符不等的递推公式中添加 d[i-1][j-1] 即可

回文

647. 回文子串

题目链接

python 复制代码

class Solution:
    def countSubstrings(self, s: str) -> int:
        n = len(s)
        dp = [[False for _ in range(n)] for _ in range(n)]
        res = 0
        for i in range(n - 1, -1, -1):
            for j in range(i, n):
                if s[i] == s[j]:
                    if j - i <= 1:
                        dp[i][j] = True
                    else:
                        dp[i][j] = dp[i+1][j-1]
                else:
                    dp[i][j] = False
                
                if dp[i][j]: res += 1
        return res

状态定义：dp[i][j] 表示 nums[i:j+1] 是否为回文串
递推公式：
- s[i] == s[j] 时，如果字符串长度为 1 或 2，则 dp[i][j] = True，反之 dp[i][j] = dp[i+1][j-1]
- s[i] != s[j] 时，dp[i][j] = False
统计 dp[i][j] 中有多少个为 True 的元素，即为答案
注意遍历范围及遍历顺序：
- 范围：上三角矩阵，要保证 i <= j
- 顺序：dp[i] 依赖于 dp[i+1]，因此 i 要倒序遍历

中心拓展法

python 复制代码

class Solution:
    def countSubstrings(self, s: str) -> int:
        n = len(s)
        res = 0

        def mid_extend(i, j):
            nonlocal res
            while i >= 0 and j < n and s[i] == s[j]:
                i -= 1
                j += 1
                res += 1

        for i in range(n):
            mid_extend(i,i)
            mid_extend(i,i+1)
        return res

枚举所有可能的中心，中心存在奇、偶两种情况

516.最长回文子序列

题目链接

python 复制代码

class Solution:
    def longestPalindromeSubseq(self, s: str) -> int:
        n = len(s)
        dp = [[0 for _ in range(n)] for _ in range(n)]
        for i in range(n - 1, -1, -1):
            for j in range(i, n):
                if s[i] == s[j]:
                    if j - i <= 1:
                        dp[i][j] = j - i + 1
                    else:
                        dp[i][j] = dp[i+1][j-1] + 2
                else:
                    dp[i][j] = max(dp[i+1][j], dp[i][j-1])
        return dp[0][n-1]

整体代码结构和上题类似
状态定义：dp[i][j] 表示 nums[i:j+1] 的最长回文子序列的长度
递推公式：
- s[i] == s[j] 时，如果字符串长度为 1 或 2，则 dp[i][j] = j - i + 1，反之 dp[i][j] = dp[i+1][j-1] + 2
- s[i] != s[j] 时，删除 s[i] 或 s[j]，取最大值，即 dp[i][j] = max(dp[i+1][j], dp[i][j-1])
注意遍历范围及遍历顺序