【动态规划】两个数组 / 字符串的dp问题（子序列、子数组问题、匹配问题、字符串问题）

于 2024-08-30 18:03:54 发布
阅读量261 收藏 7
点赞数 11
分类专栏： 算法 文章标签： 动态规划 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dreaming_TI/article/details/136755485
版权

文章目录

前言

两个数组或字符串的动态规划问题通常涉及到比较和匹配元素。以下是两个常见的例子：

  1. 最长公共子序列 (LCS) 问题

问题描述：
给定两个字符串 s1 和 s2，找出它们的最长公共子序列的长度。

  1. 编辑距离问题

问题描述：
给定两个字符串 word1 和 word2，计算将 word1 转换为 word2 所需的最小操作次数（插入、删除、替换）。

算法题

1.最长公共子序列

在这里插入图片描述

思路

  1. 定义状态：

    • 用一个二维数组 dp 来存储状态，其中 dp[i][j] 代表字符串 text1 的前 i 个字符和字符串 text2 的前 j 个字符的最长公共子序列的长度。

  2. 状态转移：

    • 如果 text1[i-1] 等于 text2[j-1]，则 dp[i][j] 取 dp[i-1][j-1] 的值加 1。
    • 如果不等，dp[i][j] 取 dp[i-1][j] 和 dp[i][j-1] 中的较大值。

  3. 初始化：

    • dp 数组初始化为 0。

  4. 结果：

    • 最终的结果是 dp[m][n]，即两个字符串的最长公共子序列的长度。

代码

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int m = text1.size(), n = text2.size();
        // 创建+初始化dp数组
        // dp[i][j]：在s1串 的{0, 1}范围 和 s2串的{0, j}范围的最长公共子序列
        vector<vector<int>> dp(m+1, vector<int>(n+1, 0));
        // 填表
        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++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]);
                }
            }

        return dp[m][n];
    }
};

2.不相交的线

在这里插入图片描述

思路

这道题实际上就是上一题的变体，也就是求最长公共子序列。

代码

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        // 即[1143.最长公共子序列](https://leetcode.cn/problems/longest-common-subsequence/description/)
        int m = nums1.size(), n = nums2.size();
        // 创建 + 初始化dp数组
        vector<vector<int>> dp(m+1, vector<int>(n+1, 0));

        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++j)
            {
                if(nums1[i - 1] == nums2[j - 1]) // 下标映射
                    dp[i][j] = dp[i-1][j-1] + 1;
                else
                    dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
            }

        return dp[m][n];
    }
};

3.不同的子序列

在这里插入图片描述

思路

  1. 状态定义：dp[i][j] 表示字符串 s 的前 j 个字符中，t 的前 i 个字符作为子序列的数量。

  2. 初始化：dp[0][j] = 1，表示 t 是空字符串时，任何 s 的前 j 个字符中都有 1 种不同的子序列（即空子序列）。

  3. 状态转移：

    • dp[i][j] += dp[i][j-1]：在当前字符 s[j-1] 不包含在子序列中的情况下的数量。
    • 如果 t[i-1] == s[j-1]，则 dp[i][j] += dp[i-1][j-1]，表示包含当前字符 s[j-1] 时的数量。

  4. 结果：dp[m][n]，表示 s 中包含 t 的所有不同子序列的数量。

  • 时间复杂度 O(m * n)
  • 空间复杂度 O(m * n)。

代码

class Solution {
public:
    int numDistinct(string s, string t) {
        int m = t.size(), n = s.size();
        // 创建+初始化 dp数组
        vector<vector<int>> dp(m+1, vector<int>(n+1));
        for(int j = 0; j <= n; ++j) dp[0][j] = 1;

        // 填表
        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++j)
            {
                dp[i][j] += dp[i][j-1];
                if(t[i-1] == s[j-1]) dp[i][j] += dp[i-1][j-1];
            }

        return dp[m][n];
    }
};

4.通配符匹配

在这里插入图片描述

思路

  1. 状态定义：

    • dp[i][j] 表示字符串 s 的前 i 个字符是否可以被模式 p 的前 j 个字符匹配。

  2. 初始化：

    • dp[0][0] = true：空字符串和空模式是匹配的。
    • 对于模式中的 *，dp[0][j] 需要设置为 true，因为 * 可以匹配零个字符。初始化时，从模式的开头开始，连续的 * 会让 dp[0][j] 设为 true。

  3. 状态转移：

    • 当模式字符 p[j] 是 * 时，dp[i][j] 可以由以下两种情况获得：
      • dp[i-1][j]：表示模式 p 的 * 匹配了 s 的当前字符，并且剩余的 s 部分可以继续匹配模式。
      • dp[i][j-1]：表示模式 p 的 * 匹配了零个字符，即模式的 * 前面的部分与 s 的当前部分匹配。
    • 当模式字符 p[j] 不是 * 时，dp[i][j] 的值取决于当前模式字符是否等于 s 的当前字符，或者模式字符是否为 ?。如果是，则 dp[i][j] 可以由 dp[i-1][j-1] 获得。

  4. 结果：

    • 最终的结果是 dp[m][n]，表示整个字符串 s 是否可以被模式 p 匹配。
  • 时间复杂度：O(m * n)，因为我们需要填充 m * n 的 dp 表。
  • 空间复杂度：O(m * n)，使用了一个 m+1 行、n+1 列的二维数组来存储中间结果。

代码

class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size(), n = p.size();
        s = " " + s, p = " " + p;
        // 创建dp数组
        vector<vector<bool>> dp(m+1, vector<bool>(n+1, false));
        // 初始化虚拟空间
        dp[0][0] = true;
        for(int j = 1; j <= n; ++j)
            if(p[j] == '*') dp[0][j] = true;
            else break;

        // 填表
        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++j)
            {
                if(p[j] == '*') {
                    dp[i][j] = dp[i-1][j] || dp[i][j-1];
                }   
                else {
                    dp[i][j] = (p[j] == '?' || p[j] == s[i]) && dp[i-1][j-1];
                }
            }

        return dp[m][n];
    }
};

5.正则表达式匹配

在这里插入图片描述

思路

  1. 初始化：

    • 在字符串 s 和模式 p 前面各加一个空格（即使 s 和 p 从索引 1 开始），这样可以简化下标操作，使 s[i] 和 p[j] 对应的下标与 dp 表一致。
    • 创建一个二维布尔数组 dp，其中 dp[i][j] 表示字符串 s 的前 i 个字符是否与模式 p 的前 j 个字符匹配。

  2. 处理模式的初始化：

    • 初始化 dp[0][j]，这表示空字符串与模式 p 的前 j 个字符的匹配。因为 * 可以匹配零个或多个字符，所以当模式的第 j 个字符是 * 时，我们需要检查 dp[0][j-2]（即模式中 * 前面的字符可能不出现的情况）。

  3. 填表：

    • 对于每个字符 s[i] 和 p[j]，检查模式 p 当前字符是 * 还是普通字符。
    • 如果是 *，有两个匹配条件：
      • dp[i][j-2]：表示 * 匹配零个字符。
      • (p[j-1] == '.' || p[j-1] == s[i]) && dp[i-1][j]：表示 * 匹配一个或多个字符。
    • 如果是普通字符，检查 p[j] 是否与 s[i] 匹配，或者 p[j] 是否为 .，然后根据 dp[i-1][j-1] 更新 dp[i][j]。

  4. 返回结果：

    • 最终的匹配结果保存在 dp[m][n] 中。

  • 时间复杂度：O(m * n)。由于我们使用了一个 m+1 行和 n+1 列的二维 DP 表，且每个元素的计算都需要常量时间，所以总体时间复杂度是 O(m * n)。

  • 空间复杂度：O(m * n)。我们使用了一个 m+1 行和 n+1 列的二维 DP 表来存储中间结果。因此，空间复杂度为 O(m * n)。

代码

class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size(), n = p.size();
        s = " " + s, p = " " + p;
        // 创建dp表
        vector<vector<bool>> dp(m+1, vector<bool>(n+1,false));
        // 初始化dp表
        dp[0][0] = true;
        for(int j = 2; j <= n; j+=2)
            if(p[j] == '*') dp[0][j] = true;
            else break;

        // 填表
        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++j)
            {
                if(p[j] == '*')
                    dp[i][j] = dp[i][j-2] || (p[j-1] == '.' || p[j-1] == s[i]) && dp[i-1][j];
                else
                    dp[i][j] = dp[i-1][j-1] && (p[j] == s[i] || p[j] == '.');
            }

        return dp[m][n];
    }
};

6.交错字符串

在这里插入图片描述

思路

  1. 初始化：

    • 创建一个二维 DP 数组 dp[i][j]，其中 dp[i][j] 表示 s1 的前 i 个字符和 s2 的前 j 个字符是否能交错组成 s3 的前 i+j 个字符。
    • dp[0][0] 初始化为 true，表示空字符串可以交错合成空字符串。
    • 对 dp[0][j] 和 dp[i][0] 进行初始化，分别处理当 s1 或 s2 为空的情况。

  2. 填表：

    • 遍历 DP 表，更新每个 dp[i][j]，根据 s1[i-1] 和 s2[j-1] 是否等于 s3[i+j-1] 来决定是否更新 dp[i][j]。

时空复杂度：

  • 时间复杂度：O(m * n)，其中 m 是 s1 的长度，n 是 s2 的长度。填充 DP 表需要遍历所有 m * n 的位置。
  • 空间复杂度：O(m * n)，需要一个大小为 m * n 的 DP 表。

代码

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int m = s1.size(), n = s2.size();
        if(m + n != s3.size()) return false;
        // 预处理：加占位符对应下标
        s1 = " " + s1, s2 = " " + s2, s3 = " " + s3;
        // 创建dp数组
        // dp[i][j]: s1{1, i}区间 与 s2[1, j]区间是否能匹配s3{1, i+j}区间
        vector<vector<bool>> dp(m+1, vector<bool>(n+1, false));
        // 初始化
        dp[0][0] = true;
        for(int j = 1; j <= n; ++j) // 初始化第一行
            if(s2[j] == s3[j]) dp[0][j] = true;
            else break;
        for(int i = 1; i <= m; ++i) // 初始化第一列
            if(s1[i] == s3[i]) dp[i][0] = true;
            else break;

        // 填表
        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++j)
            {
                dp[i][j] = (s2[j] == s3[i+j] && dp[i][j-1])
                            ||(s1[i] == s3[i+j] && dp[i-1][j]);
            }

        return dp[m][n];
    }
};

7.两个字符串的最小ASCII删除和

在这里插入图片描述

思路

  1. 定义状态：

    • dp[i][j] 表示 s1 的前 i 个字符和 s2 的前 j 个字符的公共子序列的最大ASCII值之和。

  2. 初始化和状态转移：

    • 初始化 dp[i][0] 和 dp[0][j] 为0，因为一个字符串为空时，公共子序列的ASCII和为0。
    • 对于每对 (i, j)，比较 s1[i-1] 和 s2[j-1]：
      • 如果它们相同，则 dp[i][j] 为 dp[i-1][j-1] + s1[i-1]。
      • 否则，dp[i][j] 为 max(dp[i-1][j], dp[i][j-1])。

  3. 计算结果：

    • 计算所有字符的ASCII和，并从中减去两次 dp[m][n]，因为每个字符被计算了两次。

时空复杂度：

  • 时间复杂度：O(m * n)，填充 DP 表需要遍历所有 m * n 的位置。
  • 空间复杂度：O(m * n)，需要一个大小为 m * n 的 DP 表。

代码

class Solution {
public:
    int minimumDeleteSum(string s1, string s2) {
        int m = s1.size(), n = s2.size();
        vector<vector<int>> dp(m+1, vector<int>(n+1));

        // 正难则反：求公共子序列的最大ASCII值
        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++j)
            {
                dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
                if(s1[i-1] == s2[j-1])
                    dp[i][j] = max(dp[i][j], dp[i-1][j-1] + s1[i-1]);
            }

        int sum = 0;
        for(char ch1 : s1) sum += ch1;
        for(char ch2 : s2) sum += ch2;
        return sum - dp[m][n] - dp[m][n]; // 两个字符串 需要减两次
    }
};

8.最长重复子数组

在这里插入图片描述

思路

  1. 状态定义：

    • dp[i][j] 表示 nums1 中前 i 个元素和 nums2 中前 j 个元素的最长公共子数组的长度。

  2. 初始化：

    • dp 数组初始化为 0。默认情况下，如果 i 或 j 为 0，公共子数组的长度为 0。

  3. 状态转移：

    • 如果 nums1[i - 1] 和 nums2[j - 1] 相等，则 dp[i][j] = dp[i-1][j-1] + 1。如果不相等，dp[i][j] 保持为 0。
    • 更新 ret 为 dp[i][j] 和当前 ret 的最大值，得到最大长度的公共子数组。

  4. 返回值：

    • 返回 ret，即最长公共子数组的长度。

时间复杂度：O(m * n)，需要遍历所有 m * n 的位置。

空间复杂度：O(m * n)，需要一个大小为 m * n 的 DP 表。

代码

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        // 创建dp数组 + 初始化
        // nums1以i为结尾的子数组 与 num2以j为结尾的子数组 最长重复子数组
        vector<vector<int>> dp(m+1, vector<int>(n+1, 0));
        // 填表
        int ret = 0;
        for(int i = 1; i <= m; ++i)
            for(int j = 1; j <= n; ++j)
            {
                if(nums1[i - 1] == nums2[j - 1])
                    dp[i][j] = dp[i-1][j-1] + 1, ret = max(ret, dp[i][j]);
            }
        
        return ret;
    }
};
卜及中
关注
  • 11
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java技能关键词纠错——计算两字符串最长公共子序列（动态规划）
笔墨留年。
09-26 529
前言 最近在做一项功能，需要自动从招聘文本中提取技能需求关键词。然而问题来了，请看下面这句招聘需求： 2、 熟练掌握SpringMVC、Srping、Mybetis或者hibernate，熟悉Jquery，EasyUI或者AngularJS； 稍微仔细点看，比较熟悉Java的兄dei可能已经发现了，WTF？Spring、MyBatis哭晕在厕所…… 是哪家公司的我就不说了哈，影响不好，可能就...
Python求两个字符串最长公共子序列代码实例
09-17
在编程领域，字符串操作是常见任务之一，而求解两个字符串的最长公共子序列（Longest Common Subsequence, LCS）是字符串处理中的一个重要问题。这个问题涉及到动态规划算法，它能有效地解决这类具有最优子结构和...
两个数组的dp问题(1)--动态规划
weixin_61518137的博客
07-23 321
dp[i][j]就表示s1字符串的[0，i]区间以及s2的[0，j]区间内的所有子序列中(包含以i，j为结尾，也可以不包含i，j)，找到其中的最长的公共子序列的长度。1)选取第一个字符串[0,i]区间以及第二个字符串[0,j]区间作为研究对象。二)根据状态表示推导状态转移方程:根据最后一个位置的情况来进行划分问题。一)定义一个状态表示:根据经验+题目要求。
[Algorithm][动态规划][两个数组的DP][正则表达式匹配][交错字符串][两个字符串的最小ASCII删除和][最长重复子数组]详细讲解
SnowK博客
06-07 3010
[Algorithm][动态规划][两个数组的DP][正则表达式匹配][交错字符串][两个字符串的最小ASCII删除和][最长重复子数组]详细讲解
LeetCode动态规划基础题-子字符串问题(13题)
忆_恒心的博客
05-04 1164
LeetCode子字符串问题 动态规划的问题
[Algorithm][动态规划][两个数组的DP][最长公共子序列][不相交的线][不同的子序列][通配符匹配]详细讲解
SnowK博客
06-06 3204
[Algorithm][动态规划][两个数组的DP][最长公共子序列][不相交的线][不同的子序列][通配符匹配]详细讲解
动态规划之硬币问题/迷宫问题/最大数组子序列和
WC949464367的博客
10-01 549
其实动态规划对于我最难的是边界问题 动态规划四部曲： 1.确定状态，确定从什么时候开始，就是amout 2.确定转移方程，也就是if (coins[j] <= i) { dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);//变成子问题，问题规模缩小 } 3.确定初始条件和边界条件，也就是前面和后面几步 4.确定步数和尝试次数，也就是i和j的范围 class Solut............
给定两个字符串求两个字符的最长公共子序列长度问题的解法
z1171127310的博客
11-06 1583
给定两个字符串str1和str2，求两个字符的最长公共子序列长度
DP：两个数组的dp问题
weixin_51142926的博客
06-14 1404
字符串dp技巧：空串是有研究意义的，引入空串可以帮助我们思考虚拟的边界如何进行初始化。
【动态规划】两个数组的dp问题
芥末虾的博客
07-12 474
【动态规划】两个数组的dp问题
基于C++实现的通过动态规划查找最长公共子序列计算字符串之间相似度.zip
05-10
在本项目中，我们关注的是使用C++编程语言来实现这一算法，通过动态规划的方法找到两个字符串的最长公共子序列。 动态规划是一种解决复杂问题的有效方法，它通过将大问题分解为相互关联的小问题，并存储这些小问题...
使用Java实现的计算两字符串相似度+最长公共子序列.zip
05-10
在计算机科学领域，字符串处理是常见的一类任务，其中计算两个字符串的相似度以及找到它们的最长公共子序列（Longest Common Subsequence, LCS）是一个经典的问题。本篇将深入探讨这个问题，以及如何使用Java来解决...
ASM_DP_基于动态规划的近似串匹配算法CPP实现_
10-03
总的来说，"ASM_DP_基于动态规划的近似串匹配算法CPP实现_"这一资源提供了一个实际的C++实现，帮助我们了解如何利用动态规划解决近似字符串匹配问题。对于想要提升算法技能，尤其是对动态规划和字符串处理感兴趣的IT...
递归、搜索与回溯算法
最新发布
无聊_人的博客
08-29 1384
所谓的递归其实就是函数自己调用自己的情况。
力扣（无重叠区间）
yyssas的博客
08-29 1463
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 1273
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 1563
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
C语言刷题日记(附详解)(2)
ixiaotang_的博客
08-24 3735
你所厌恶的今天，是昨天死去之人奢望的明天。你所浪费的现在，是未来的你回不去的曾经。时间如此宝贵，作为学生，学习就是我们的职责，那么不要懈怠！让我们开始今天的学习吧！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值