2024/06/21--代码随想录算法10-12/17| 子序列问题

最新推荐文章于 2024-07-13 23:05:26 发布

西西，正在减肥

最新推荐文章于 2024-07-13 23:05:26 发布

阅读量656

点赞数 10

分类专栏：力扣刷题 # 动态规划文章标签：算法动态规划

本文链接：https://blog.csdn.net/qq_46277517/article/details/139871453

版权

力扣刷题同时被 2 个专栏收录

26 篇文章 0 订阅

订阅专栏

动态规划

10 篇文章 0 订阅

订阅专栏

300.最长递增子序列

力扣链接
在这里插入图片描述

==动规五部曲 ==

dp的定义
dp[i]表示子序列答案以nums[i]结尾的最长递增子序列的长度
为什么一定表示 “以nums[i]结尾的最长递增子序” ，因为我们在做递增比较的时候，如果比较 nums[j] 和 nums[i] 的大小，那么两个递增子序列一定分别以nums[j]为结尾和 nums[i]为结尾，要不然这个比较就没有意义了，不是尾部元素的比较那么如何算递增呢。
状态转移方程：

位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。
所以：if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);

dp初始化
每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1
确认遍历顺序：
dp[i] 是有0到i-1各个位置的最长递增子序列推导而来，那么遍历i一定是从前向后遍历。
j其实就是遍历0到i-1，那么是从前到后，还是从后到前遍历都无所谓，只要吧 0 到 i-1 的元素都遍历了就行了。所以默认习惯从前向后遍历。
遍历i的循环在外层，遍历j则在内层

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        if len(nums) <= 1:
            return len(nums)
        dp = [1] * len(nums)
        result = 1
        for i in range(1, len(nums)):
            for j in range(0, i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[i], dp[j] + 1)
            result = max(result, dp[i]) #取长的子序列
        return result

贪心

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        if len(nums) <= 1:
            return len(nums)
        
        tails = [nums[0]]  # 存储递增子序列的尾部元素
        for num in nums[1:]:
            if num > tails[-1]:
                tails.append(num)  # 如果当前元素大于递增子序列的最后一个元素，直接加入到子序列末尾
            else:
                # 使用二分查找找到当前元素在递增子序列中的位置，并替换对应位置的元素
                left, right = 0, len(tails) - 1
                while left < right:
                    mid = (left + right) // 2
                    if tails[mid] < num:
                        left = mid + 1
                    else:
                        right = mid
                tails[left] = num
        
        return len(tails)  # 返回递增子序列的长度

674.最长连续递增序列

力扣链接
在这里插入图片描述

==动规五部曲 ==

dp的定义
dp[i]表示子序列答案以nums[i]结尾的最长递增子序列的长度
状态转移方程：

if nums[i] > nums[i-1]:     dp[i] = dp[i-1]+1

dp初始化
每一个i，对应的dp[i]（即最长递增子序列）起始大小至少都是1
确认遍历顺序：

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

贪心

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        if len(nums) == 0:
            return 0
        result = 1 #连续子序列最少也是1
        count = 1
        for i in range(len(nums)-1):
            if nums[i+1] > nums[i]: #连续记录
                count += 1
            else: #不连续，count从头开始
                count = 1
            result = max(result, count)
        return result

718.最长重复子数组【公共连续】

力扣链接
在这里插入图片描述

==动规五部曲 ==

dp的定义
dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]
（特别注意： 这个公共子字符串是下标i - 1为结尾的A ）
状态转移方程：

 if nums1[i - 1] == nums2[j - 1]:
 # 在当前位置上的最长公共子数组长度为前一个位置上的长度加一
       dp[i][j] = dp[i - 1][j - 1] + 1

dp初始化
dp[i][0] =dp[0][j]=0。
确认遍历顺序：

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        # 创建一个二维数组 dp，用于存储最长公共子数组的长度
        dp = [[0] * (len(nums2) + 1) for _ in range(len(nums1) + 1)]
        # 记录最长公共子数组的长度
        result = 0

        # 遍历数组 nums1
        for i in range(1, len(nums1) + 1):
            # 遍历数组 nums2
            for j in range(1, len(nums2) + 1):
                # 如果 nums1[i-1] 和 nums2[j-1] 相等
                if nums1[i - 1] == nums2[j - 1]:
                    # 在当前位置上的最长公共子数组长度为前一个位置上的长度加一
                    dp[i][j] = dp[i - 1][j - 1] + 1
                # 更新最长公共子数组的长度
                res = max(res, dp[i][j])

        # 返回最长公共子数组的长度
        return result

1143.最长公共子序列【公共子序列】

力扣链接
在这里插入图片描述

==动规五部曲 ==

dp的定义
dp[i][j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]
状态转移方程：

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])

dp初始化
dp[i][0] =dp[0][j]=0。
确认遍历顺序：

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        # 创建一个二维数组 dp，用于存储最长公共子序列的长度
        dp = [[0] * (len(text2) + 1) for _ in range(len(text1) + 1)]
        
        # 遍历 text1 和 text2，填充 dp 数组
        for i in range(1, len(text1) + 1):
            for j in range(1, len(text2) + 1):
                if text1[i - 1] == text2[j - 1]:
                    # 如果 text1[i-1] 和 text2[j-1] 相等，则当前位置的最长公共子序列长度为左上角位置的值加一
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    # 如果 text1[i-1] 和 text2[j-1] 不相等，则当前位置的最长公共子序列长度为上方或左方的较大值
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
        
        # 返回最长公共子序列的长度
        return dp[len(text1)][len(text2)]

1035.不相交的线【公共子序列】

力扣链接
在这里插入图片描述
本题说是求绘制的最大连线数，其实就是求两个字符串的最长公共子序列的长度！

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

53.最大子序和

力扣链接
在这里插入图片描述

==动规五部曲 ==

dp的定义
dp[i]：包括下标i（以nums[i]为结尾）的最大连续子序列和为dp[i]。
状态转移方程：

        for i in range(1, len(nums)):
            dp[i] = max(dp[i-1] + nums[i], nums[i]) #状态转移公式

dp初始化
dp[0] = nums[0]
确认遍历顺序：

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        dp = [0] * len(nums)
        dp[0] = nums[0]
        result = dp[0]   # res的初始值是dp[0]，不是0
        for i in range(1, len(nums)):
            dp[i] = max(dp[i-1] + nums[i], nums[i]) #状态转移公式
            result = max(result, dp[i]) #result 保存dp[i]的最大值
        return result

392.判断子序列【s在t是否出现】

力扣链接
在这里插入图片描述

==动规五部曲 ==

dp的定义
dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。
状态转移方程：

if s[i-1] == t[j-1]:
	dp[i][j] = dp[i-1][j-1] + 1
else:
	dp[i][j] = dp[i][j-1]

dp初始化
dp[0][0]和dp[i][0]为0
确认遍历顺序：

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

115.不同的子序列【s在t出现的个数】

力扣链接
在这里插入图片描述

==动规五部曲 ==

dp的定义
dp[i][j]：以i-1为结尾的s子序列中,出现以j-1为结尾的t的个数为dp[i][j]。【s[0：i] 中，t[0：j]出现的个数】
状态转移方程：

if s[i-1] == t[j-1]:
	dp[i][j] = dp[i-1][j-1] + dp[i-1][j]
	#1.用上了s[i-1]   2. 没有用上s[i-1],把s[i-1]删掉
else:
	dp[i][j] = dp[i-1][j]

dp初始化
dp[0][j]=0
dp[i][0]:以i-1为结尾的s可以随便删除元素，出现空字符串的个数。
确认遍历顺序：

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)):
            dp[i][0] = 1
        for j in range(1, len(t)):
            dp[0][j] = 0
        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]

583. 两个字符串的删除操作

力扣链接
在这里插入图片描述

==动规五部曲 ==

dp的定义
dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。
状态转移方程：

if word1[i-1] == word2[j-1]:
    dp[i][j] = dp[i-1][j-1]
else:
    dp[i][j] = min(dp[i-1][j-1] + 2, dp[i-1][j] + 1, dp[i][j-1] + 1)

dp初始化
dp[0][j]=j
dp[i][0]=i
确认遍历顺序：

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 j in range(len(word2)+1):
            dp[0][j] = j
        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-1][j-1] + 2, dp[i-1][j] + 1, dp[i][j-1] + 1)
        return dp[-1][-1]

class Solution(object):
    def minDistance(self, word1, word2):
        m, n = len(word1), len(word2)
        
        # dp 求解两字符串最长公共子序列
        dp = [[0] * (n+1) for _ in range(m+1)]
        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] + 1
                else:
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1])
                    
        # 删去最长公共子序列以外元素
        return m + n - 2 * dp[-1][-1]

72.编辑距离

力扣链接
在这里插入图片描述

==动规五部曲 ==

dp的定义
dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，最小编辑距离为dp[i][j]。。
状态转移方程：

if word1[i-1] == word2[j-1]:
    dp[i][j] = dp[i-1][j-1]
else:
    dp[i][j] = min(dp[i-1][j-1] + 1, dp[i-1][j] + 1, dp[i][j-1] + 1)

dp初始化
dp[0][j]=j
dp[i][0]=i
确认遍历顺序：

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 j in range(len(word2)+1):
            dp[0][j] = j
        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-1][j-1] + 1, dp[i-1][j] + 1, dp[i][j-1] + 1)
        return dp[-1][-1]

编辑距离总结篇

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

if (s[i - 1] == t[j - 1]) 
	dp[i][j] = dp[i - 1][j - 1] + 1
else：
	dp[i][j] = dp[i][j - 1]  #相当于t要删除元素，继续匹配

给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

if (s[i - 1] == t[j - 1])
    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]
    #一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]。
    #一部分是不用s[i - 1]来匹配，个数为dp[i - 1][j]。
else ：
    dp[i][j] = dp[i - 1][j];

给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最少步数，每步可以删除任意一个字符串中的一个字符。

if (word1[i - 1] == word2[j - 1]) ：
    dp[i][j] = dp[i - 1][j - 1]
else ：
    dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1})

给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数。

if (word1[i - 1] == word2[j - 1])：
    dp[i][j] = dp[i - 1][j - 1];
else：
    dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1

西西，正在减肥

关注

10
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
2024/06/21--代码随想录算法10-12/17| 子序列问题

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。else：dp[i][j] = dp[i][j - 1] #相当于t要删除元素，继续匹配给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。#一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]。#一部分是不用s[i - 1]来匹配，个数为dp[i - 1][j]。
复制链接

扫一扫