【leetcode】动态规划刷题tricks-子序列问题

1.不连续子序列问题

LeetCode300题 最长递增子序列

动态规划解法-时间复杂度n*n

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        # dp[i]表示以nums[i]结尾的最长递增子序列的长度
        dp = [1] * len(nums)
        res = 1
        for i in range(1, len(nums)):
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j] + 1)
            res = max(res, dp[i])
        return res

贪心 + 二分查找解法-时间复杂度n*log(n)

如果要使递增子序列尽可能的长，需要让序列上升得尽可能慢，因此希望每次在递增子序列最后加上的那个数尽可能的小。

所以可维护一个数组d，d[i]表示长度为i + 1的最长递增子序列的末尾元素的最小值，不断更新d，d的最终长度就是最长自增子序列长度。

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        d = []
        for i in range(len(nums)):
            if not d or nums[i] > d[-1]:
                d.append(nums[i])
            else:
                # 二分查找，找到d中第一个比nums[i]小的数d[k]，并让d[k + 1] = nums[i]
                l, r = 0, len(d) - 1
                while l <= r:
                    mid = (l + r) // 2
                    if d[mid] < nums[i]:
                        l = mid + 1
                    elif d[mid] > nums[i]:
                        r = mid - 1
                    else:
                        l = mid
                        break
                d[l] = nums[i]
        return len(d)

 LeetCode1143题 最长公共子序列

由于递推公式是从上到下、从左到右，所以无法压缩为1维DP数组

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        # dp[i][j]表示text1[0: i]与text2[0: j]的最长公共子序列长度
        dp = [[0] * (len(text2) + 1) for _ in range(len(text1) + 1)]
        for i in range(1, len(text1) + 1):
            for j in range(1, len(text2) + 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[-1][-1]

2.连续子序列问题

LeetCode674题 最长连续递增序列

相对“最长递增子序列”，本题简单在，每次只需要比较和前一个元素的大小

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        # dp[i]表示以nums[i]结尾的最长连续递增子序列的长度
        dp = [1] * len(nums)
        res = 1
        for i in range(1, len(nums)):
            if nums[i] > nums[i - 1]:
                dp[i] = dp[i - 1] + 1
            res = max(res, dp[i])
        return res

LeetCode718题 最长重复子数组

二维DP数组解法

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        # dp[i][j]表示以nums1[i]、nums2[j]结尾的最长重复子数组长度
        # dp[i][j] = dp[i-1][j-1] + 1
        res = 0
        dp = [[0] * len(nums2) for _ in range(len(nums1))]
        for i in range(len(nums1)):
            for j in range(len(nums2)):
                if nums1[i] == nums2[j]:
                    if j == 0 or i == 0:
                        dp[i][j] = 1
                    else:
                        dp[i][j] = dp[i - 1][j - 1] + 1
                res = max(res, dp[i][j])
        return res

一维DP数组解法

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        # dp[i][j]表示以nums1[i]、nums2[j]结尾的最长重复子数组长度
        # dp[i][j] = dp[i-1][j-1] + 1
        res = 0
        dp = [0] * len(nums2)
        for i in range(len(nums1)):
            # 需要倒序遍历
            for j in range(len(nums2) - 1, -1, -1):
                if nums1[i] == nums2[j]:
                    if j == 0 or i == 0:
                        dp[j] = 1
                    else:
                        dp[j] = dp[j - 1] + 1
                # 不要忘了
                else:
                    dp[j] = 0
                res = max(res, dp[j])
        return res

LeetCode53题 最大子序和

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        res = nums[0]
        # dp[i]表示以nums[i]为结尾的最大子序和，可压缩为1维变量
        dp = nums[0]
        for i in range(1, len(nums)):
            if dp > 0:
                dp = dp + nums[i]
            else:
                dp = nums[i]
            res = max(res, dp)
        return res

3.编辑距离问题

LeetCode392题 判断子序列

与“最长公共子序列”区别在于，s[j-1]!=t[i-1]时，dp[i][j]=dp[i-1][j]，即只删除t中的元素，不需要删除s中的元素比较。所以还可以压缩为1维DP数组。

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

LeetCode115题 不同的子序列

也可优化为一维DP数组解法

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

LeetCode583题 两个字符串的删除操作

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        dp = [[0] * (len(word1) + 1) for _ in range(len(word2) + 1)]
        for i in range(len(word1) + 1):
            dp[0][i] = i
        for i in range(len(word2) + 1):
            dp[i][0] = i
        for i in range(1, len(word2) + 1):
            for j in range(1, len(word1) + 1):
                if word1[j - 1] == word2[i - 1]:
                    dp[i][j] = dp[i - 1][j - 1]
                else:
                    # dp[i - 1][j - 1] + 2也可以去掉，dp[i - 1][j] = dp[i - 1][j - 1] + 1
                    dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + 2)
        return dp[-1][-1]

LeetCode72题 编辑距离

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        dp = [[0] * (len(word2) + 1) for _ in range(len(word1) + 1)]
        for i in range(len(word1) + 1):
            dp[i][0] = i
        for i in range(len(word2) + 1):
            dp[0][i] = i
        for i in range(1, len(word1) + 1):
            for j in range(1, len(word2) + 1):
                if word1[i - 1] == word2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1]
                else:
                    # 分别代表插入、删除、替换操作
                    dp[i][j] = min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1
        return dp[-1][-1]

4.回文问题

LeetCode647题 回文子串

动态规划解法

class Solution:
    def countSubstrings(self, s: str) -> int:
        res = 0
        # dp[i][j]表示s[i: j+1]是否为回文串
        dp = [[False] * len(s) for _ in range(len(s))]
        for i in range(len(s) - 1, -1, -1):
            for j in range(i, len(s)):
                if s[i] == s[j]:
                    if i + 1 > j - 1:
                        dp[i][j] = True
                    else:
                        dp[i][j] = dp[i+1][j-1]
                if dp[i][j]:
                    res += 1
        return res

双指针解法-空间复杂度低

class Solution:
    def countSubstrings(self, s: str) -> int:
        # 中心扩散函数
        def get_Center(s, l, r):
            count = 0
            while l >= 0 and r < len(s) and s[l] == s[r]:
                l -= 1
                r += 1
                count += 1
            return count
        
        res = 0
        for i in range(len(s)):
            res += get_Center(s, i, i) + get_Center(s, i, i+1)
        return res

LeetCode516题 最长回文子序列

class Solution:
    def longestPalindromeSubseq(self, s: str) -> int:
        # dp[i][j]表示s[i: j + 1]的最长回文子序列长度
        dp = [[0] * len(s) for _ in range(len(s))]
        for i in range(len(s) - 1, -1, -1):
            for j in range(i, len(s)):
                if s[i] == s[j]:
                    if j - i == 0:
                        dp[i][j] = 1
                    elif j - i == 1:
                        dp[i][j] = 2
                    else:
                        dp[i][j] = dp[i + 1][j - 1] + 2
                else:
                    # 此时肯定j>i
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])
        return dp[0][len(s) - 1]