【两个数组DP】最长公共子序列 / 通配符匹配 / 正则表达式匹配 / 最长重复子数组

已于 2025-04-08 12:52:28 修改
阅读量1.1k 收藏 9
点赞数 22
分类专栏： # 动态规划 文章标签： 算法 动态规划
于 2025-03-26 00:14:40 首次发布
小羊在奋斗
本文链接：https://blog.youkuaiyun.com/2301_78843337/article/details/146503535
版权
头像
⭐️个人主页：@小羊
⭐️所属专栏：动态规划
很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~

动图描述

目录

最长公共子序列

在这里插入图片描述

定义状态 dp[i][j] 为s1的[0, i]区间和s2的[0, j]区间中所有的子序列中，最长公共子序列的长度。

在这里插入图片描述

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int m = text1.size(), n = text2.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        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];
    }
};

不相交的线

在这里插入图片描述

说白了我白说了，这就是 “最长公共子序列”。
我是程序猿，我可以作证，代码一模一样。

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        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-1][j], dp[i][j-1]);
            }
        }
        return dp[m][n];
    }
};

不同的子序列

在这里插入图片描述

dp[i][j] 表示s的[0, j]区间中所有的子序列中有多少个t的[0, j]区间的子串。

在这里插入图片描述

class Solution {
public:
    int numDistinct(string s, string t) {
        const int mod = 1e9 + 7;
        int m = t.size(), n = s.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        for (int i = 0; i < n; i++) dp[0][i] = 1;
        for (int i = 1; i <= m; i++)
        {
            for (int j = 1; j <= n; j++)
            {
                dp[i][j] = dp[i][j - 1];
                if (s[j - 1] == t[i - 1])
                    dp[i][j] = (dp[i][j] + dp[i - 1][j - 1]) % mod;
            }
        }
        return dp[m][n];
    }
};

通配符匹配 *

在这里插入图片描述

dp[i][j] 表示 p[0, j] 内的子串能否匹配 s[0, i] 内的子串。

在这里插入图片描述

class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size(), n = p.size();
        // 对应下标
        s = ' ' + s;
        p = ' ' + p;
        vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));

        // 初始化空串的情况
        dp[0][0] = true;
        for (int i = 1; i <= n; i++)
            if (p[i] == '*') dp[0][i] = 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] == '?' || s[i] == p[j]) && dp[i - 1][j - 1];

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

正则表达式匹配

在这里插入图片描述

定义状态 dp[i][j] 表示 p[0, j] 区间内的子串能否匹配 s[0, i] 区间内的子串。

在这里插入图片描述

在这里插入图片描述

class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size(), n = p.size();
        // 对应下标
        s = ' ' + s;
        p = ' ' + p;
        vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));

        // 初始化空串的情况
        dp[0][0] = true;
        for (int i = 2; i <= n; i += 2)
            if (p[i] == '*') dp[0][i] = 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] || ((s[i] == p[j-1] || p[j-1] == '.') && dp[i-1][j]);
                else
                    dp[i][j] = (s[i] == p[j] || p[j] == '.') && dp[i-1][j-1];
            }
        }
        return dp[m][n];
    }
};

交错字符串

在这里插入图片描述

定义状态 dp[i, j] 表示 s1[0, i] 区间内的字符串和 s2[0, j] 区间内的字符串能否拼接成 s3[0, i + j] 区间内的字符串。

在这里插入图片描述

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;

        vector<vector<bool>> dp(m + 1, vector<bool>(n + 1));
        dp[0][0] = true;
        for (int i = 1; i <= n; i++)
            if (s2[i] == s3[i]) dp[0][i] = true;
            else break;
        for (int i = 0; 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] = (s1[i] == s3[i + j] && dp[i - 1][j]) 
                            || (s2[j] == s3[i + j] && dp[i][j - 1]);
        return dp[m][n];
    }
};

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

在这里插入图片描述

实际就是求两个字符串的最长公共子序列的ASCII码和。

定义状态 dp[i][j] 表示s1[0, i]区间和s2[0, j]区间内的所有子序列中，最长公共子序列的ASCII码和。

在这里插入图片描述

对于初始化dp表，当s1为空串或s2为空串时，dp[0][i] 和 dp[j][0] 都为0。

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));
        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 ch : s1) sum += ch;
        for (char ch : s2) sum += ch;
        return sum - dp[m][n] - dp[m][n];
    }
};

最长重复子数组

在这里插入图片描述

在这里插入图片描述

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size(), n = nums2.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        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;
    }
};

本篇文章的分享就到这里了，如果您觉得在本文有所收获，还请留下您的三连支持哦~

头像
Java 求解回文子串
南淮北安的博客
10-26 758
文章目录一、题目二、题解三、代码四、总结 一、题目 给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。 具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。 二、题解 （1）确定dp数组（dp table）以及下标的含义 布尔类型的dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。 （2）确定递推公式 在确定递推公式时，就要分析如下几种情况。 整体上是两种，就是s[i]与s[j]相等，
动态规划算法专题（七）：两个数组的dp问题
2401_83595513的博客
10-15 1729
DP(七)_根据最后一个位置的状况，划分问题
小乐乐匹配字符串（最长公共子序列）
ccsu_deer
12-03 503
链接：https://ac.nowcoder.com/acm/contest/301/E 来源：牛客网 小乐乐匹配字符串 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32768K，其他语言65536K 64bit IO Format: %lld 题目描述 小乐乐有字符串str1,str2。 小乐乐想要给他们找朋友。 小乐乐想知道在这两个字符串中最多能匹配出多长的...
回文子串（动态规划）
caijhBlog的博客
10-09 503
Longest Palindromic Substring
回文子串-动态规划
qq_42692908的博客
02-11 252
题目 给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。 回文字符串 是正着读和倒过来读一样的字符串。 子字符串 是字符串中的由连续字符组成的一个序列。 具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。 示例 输入：s = “abc” 输出：3 算法 dp[i][j]表示s[i…j]是否是回文串 只有但s[i]==s[j]时，才有可能是回文串 如果i+1 >= j-1,则不需要看dp[i+1][j-1]是否是回文串 否则，要看dp.
两个字符串匹配出最长公共子序列算法
m0_63251896的博客
05-23 333
最长公共子序列（Longest Common Subsequence, LCS）是一个经典的计算机科学问题，它寻找两个字符串序列中最长的公共子序列。一个子序列是指在不改变字符顺序的情况下，通过删除某些字符（也可能不删除）得到的新序列。可以得出第二个空为str1[i-1]==str2[j-1].可以看出21年的软考下午题试题4很简单。而第三空可以直接写出d[i-1][j-1]+1,离谱了，没见过像21年的软考题那么简单。根据式子一，二，若len1=0或者len2=0，等于j或者i。
LeetCode中的正则表达式和通配符匹配问题
最新发布
百态老人的博客
02-04 652
使用滚动哈希集合将空间复杂度从 O(mn) 降低到 O(min(m, n))。优化状态转移方程，减少不必要的状态存储。使用记忆化递归处理较短字符串，减少重复计算。合理初始化和处理边界条件，避免不必要的状态存储。如果需要处理复杂的模式匹配任务，正则表达式是更好的选择，尽管其语法复杂性较高。如果仅需进行简单的文件名匹配或命令行操作，通配符更为高效且易于使用。在性能敏感的应用中，建议根据具体需求选择合适的工具。例如，在处理大量数据时，优先考虑使用通配符以提高性能。
动态规划六——两个数组的dp问题
2301_80224556的博客
01-05 1213
来进行分类讨论，以确定状态转移方程。当。
动态规划＜九＞两个数组的dp
Miwll的博客
01-27 1131
两个数组的dp
第二章、动态规划算法(2.4.1-2.4.2.3)------匹配问题
Python基础详解教程，让编程变得简单！
11-26 1738
文中主要讲述动态规划算法在匹配问题的应用，主要包括通配符匹配问题、正则表达式匹配问题、子状态空间与子状态。
最长公共子串、最长公共子序列、最长回文子串、模式匹配、最大子序列--字符串问题整理
Invoker's Tower
08-25 5679
一.最长公共子串问题集（Longest Common Substring/LCS）     最长公共子串问题的基本表述为：     给定两个字符串，求出它们之间最长的相同子字符串的长度。     最直接的解法自然是找出两个字符串的所有子字符串进行比较看他们是否相同，然后取得相同最长的那个。对于一个长度为n的字符串，它有n(n+1)/2 个非空子串。所 以假如两个字符串的长度同为n，通
动态规划—回文子串的问题
qq_40373277的博客
04-01 162
回文字串问题 516. 最长回文子序列 给定一个字符串s 找到其中最长的回文子序列 可以假设s的最大长度为1000 (注意这里的回文子序列不一定是连续的) n = len(s) dp = [[0] for _ in range(n)] for _ in range(n)] # dp[i][j] 表示第i个到第j个字符间的子序列的个数（i < j） for i in range(n): dp...
动态规划--回文串问题
weixin_61518137的博客
07-22 1412
3.1)如果array[i]!=array[j]那么从i位置到j位置的这段字符串，一定不是回文串。我们从左向右遍历字符串中的每一个字符，遍历到某一个字符之后，我们向左向右各走一步，，dp[i][j]表示以i位置为起点，j位置为中点的子串，是否是回文串。但是如果是偶数的情况，可以是选取两个字符从中间向两边进行扩展。暴力枚举:将所有的三元组字符串给进行枚举一下，判断这个字符的左右两边是否相等。
动态规划——回文串问题
zdlynj的博客
10-25 1525
如果 [0，i] 区间 中有一个位置 j 切割出来一个 [j，i] 的子串，如果[j，i] 是一个回文串，接下来在 [0，j-1] 看看切割少次，然后再加上切出来的[j，i] 这一次就可以了。填表顺序：在求dp[i][j] 的值时，我们需要用到 dp[i+1][j-1]位置的值，所以需要从下往上，从左往右依次填写dp表。dp[i][j]表示字符串s里面 [i，j] 区间内的子串，使它成为回文串的最小插入次数，而我们要的是整个区间的最小插入次数，因此返回 dp[0][m-1]
动态规划学习——回文串
qq_41934502的博客
12-03 1504
回文子串，构成回文串的最小分割次数
动态规划：回文串系列
啊哦的博客
03-08 522
1、最长回文子串 寻找回文串的问题核心思想是：从中间开始向两边扩散来判断回文串 for 0 <= i < len(s): 找到以 s[i] 为中心的回文串；（奇数） 找到以 s[i] 和 s[i+1] 为中心的回文串 （偶数） 更新答案 class Solution { public String longestPalindrome(String s) { String result=""; for(int i=0;i&lt
【算法专题】动态规划之回文子串问题
YoungMLet的博客
01-28 3343
算法专题之动态规划 - - - 回文子串问题
【动态规划】回文串问题
fight_p的博客
09-14 2376
【动态规划】回文串问题
动态规划实现通配符匹配算法及源码解析
资源摘要信息:"通配符匹配是计算机科学中字符串处理的一部分，尤其在文件系统和正则表达式中广泛应用。问题的核心在于检测一个给定的文本字符串是否符合某个特定的模式，其中模式可能包含通配符。常见的通配符包括星...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值