蓝桥杯DP问题小结（二）

二、子序列问题

1. 最长递增子序列（非连续）

        给你一个整数数组nums，找到其中最长严格递增子序列的长度。子序列是由数组派生而来的序列，删除(或不删除)数组中的元素而不改变其余元素的顺序。例如[3,6,2,7]是数组[0,3,1,6,2,2,7]的子序列。【力扣链接】

N = int(input())
arr = [int(k) for k in input().split()]
# dp数组的含义dp[i]为第1 ~ i个数的最长递增数
dp = [1]*(N + 10)
for i in range(1, N):
    for j in range(0, i):
        if arr[i] > arr[j]:
            dp[i] = max(dp[j] + 1, dp[i])

print(max(dp))

2. 最长递增子序列（连续）

        给定一个未经排序的整数数组，找到最长且 连续递增的子序列，并返回该序列的长度。连续递增的子序列可以由两个下标和r(l<r)确定，如果对于每个l<= i<r，都有nums[i]<nums[i+1]，那么子序列[nums[l],nums[l+1]，..,nums[r-1]，nums[r]]就是连续递增子序列。【力扣链接】

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

3.最长重复子数组

        给两个整数数组nums1和nums2返回 两个数组中 公共的、长度最长的子数组的长度。【力扣链接】

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        length1 = len(nums1)
        length2 = len(nums2)
        # 定义dp数组，dp[i][j]表示的是以num1的i - 1结尾的和以nums2的j - 1结尾的公共长度
        # 初始化
        res = 0
        dp = [[0] * (length1 + 10) for _ in range(length2 + 10)]
        # 循环
        for i in range(1, length1 + 1):
            for j in range(1, length2 + 1):
                if nums1[i - 1] == nums2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                if res < dp[i][j]:
                    res = dp[i][j]
        return res

4. 最长公共子序列

        给定两个字符串text1和text2，返回这两个字符串的最长公共子序列 的长度。如果不存在公共子序列，返回0。一个字符串的子席列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。两个字符串的公共子序列是这两个字符串所共同拥有的子序列。【力扣链接】

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

5. 最大子序和

        给你一个整数数组nums，请你找出一个具有最大和的连续子数组(子数组最少包含一个元素)，返回其最大和。【力扣链接】

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        length = len(nums)
        dp =[0]* length
        dp[0] = nums[0]
        ans = nums[0]
        for i in range(1, length):
            dp[i] = max(dp[i -1] + nums[i], nums[i])
            if ans < dp[i]:
                ans = dp[i]
        return ans

        这题的递推公式有点类似于背包问题，dp[i]的取值的来源在于取这个物品和不取这个物品两种情况。为了更好的理解本道题，本人给出了更精确的写法。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        length = len(nums)
        dp =[0]* length
        min_num = min(nums)
        dp[0] = nums[0]
        ans = nums[0]
        for i in range(1, length):
            # 如果前面的总和是负数，那么最大的值肯定是nums[i]
            if dp[i - 1] < 0:
                dp[i] = nums[i]
            # 如果前面的总和不是负数，那么继续相加，看看后面的情况
            else:
                dp[i] = dp[i -1] + nums[i]

            if ans < dp[i]:
                ans = dp[i]
        return ans

三、编辑距离

1. 判断子序列

        字符串的一个子序列是原始字符串删除一些(也可以不删除)字符而不改变剩余字符相对位置形成的新字符串。(例如，"ace"是"abcde"的一个子序列，而"aec"不是)。【力扣链接】

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

        本题思路很简单，就是看看给出的子序列的和序列二者的最大公共子序列的长度和子序列的长度是否一样。

2. 不同的子序列

        给定一个字符串s和一个字符串t，计算在s的子序列中t出现的个数。字符串的一个子序列是指，通过删除一些(也可以不删除)字符且不干扰剩余字符相对位置所组成的新字符串。力扣链接

class Solution:
    def numDistinct(self, s: str, t: str) -> int:
        length1 = len(s)
        length2 = len(t)
        dp = [[0] * (length2 + 1) for _ in range(length1 + 1)]
        for i in range(length1 + 1):
            dp[i][0] = 1
        for j in range(length2 + 1):
            dp[0][j] = 0
        dp[0][0] = 1
        for i in range(1, length1 + 1):
            for j in range(1, length2 + 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[length1][length2]

        总结：对于编辑距离的问题，要先弄清楚如何将两个字符串进行转换，删除，添加和替换操作,每一个操作对应的递推公式，进行组合计算。当然了遍历顺序和初始化也是一个很重要的步骤，要仔细分析，图形结合来求解。