【动态规划六】两个数组的dp问题

最新推荐文章于 2024-06-22 21:53:36 发布
最新推荐文章于 2024-06-22 21:53:36 发布
阅读量996 收藏 10
点赞数 16
分类专栏： 算法 文章标签： 动态规划 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74126249/article/details/139027230
版权

目录

leetcode题目

一、最长公共子序列

二、不相交的线

三、不同的子序列

四、通配符匹配

五、正则表达式匹配

六、交错字符串

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

八、最长重复子数组

leetcode题目

一、最长公共子序列

1143. 最长公共子序列 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/longest-common-subsequence/1.题目解析

找两个字符串的最长公共子序列的长度

2.算法分析

1.状态表示

经验+题目要求: 选取第一个字符串[0, i] 区间以及第二个字符串[0, j] 区间作为研究对象

dp[i][j]: s1的[0, i]区间以及s2的[0, j]区间所有的子序列中，最长的公共子序列的长度

2.状态转移方程

根据最后一个位置的情况，分情况讨论

3.初始化

在原始dp表上添加一行一列,  第一行表示第一个字符串为空，第二行表示第二个字符串为空，根据实际含义，将第一行第一列都填成0，填表就不会越界了并且后续填表是正确的，而我们可以在s1和s2前面都加'_', 这样dp表和原始字符串的下标就一一对应了

4.填表顺序

从上往下填表，每一行从左往右

5.返回值

dp[m][n]

3.算法代码

class Solution {
public:
    int longestCommonSubsequence(string s1, string s2) 
    {
        int m = s1.size(), n = s2.size();
        //1.创建dp表 + 初始化
        vector<vector<int>> dp(m+1, vector<int>(n+1));
        s1 = " " + s1, s2 = " " + s2; 
        //2.填表
        for(int i = 1; i <= m; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                if(s1[i] == s2[j])
                    dp[i][j] = dp[i-1][j-1] + 1;
                else
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
        //3.返回值
        return dp[m][n];
    }
};

二、不相交的线

1035. 不相交的线 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/uncrossed-lines/1.题目解析

给定两个数组，要求将两个数组中相同的元素进行连线，但是不能相交，并且一个数字只能属于一个线， 求最多的线段个数

2.算法分析
本质和题目一是一样的，只是题目一是在两字符串中求最长公共子序列，而本题是在两个数组中秋最长公共子序列
解法和题目一是一模一样的~
只是本题直接在数组前加空格不太方便，可以用修改下标映射关系，让其一一对应即可
3.算法代码

class Solution 
{
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2)
    {
        int m = nums1.size(), n = nums2.size();
        //1.创建dp表 + 初始化
        vector<vector<int>> dp(m+1, vector<int>(n+1));
        //2.填表
        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]);
            }
        }
        //3.返回值
        return dp[m][n];
    }
};

三、不同的子序列

115. 不同的子序列 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/distinct-subsequences/

1.题目解析

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数

2.算法分析

1.状态表示

dp[i][j]: s字符串的[0, j]区间内的所有子序列中，有多少个t字符串[0, i]区间内的子串

2.状态转移方程

3.初始化

dp表添加一行一列, t字符串和s字符串前加 "_"

第一行i位0， 表示t是空串，这种情况下无论s是啥样子，只要一个不选，就是空串，因此第一行全部初始化成1

第一列i为0， 表示s是空串，这种情况下只有当t是空串(dp[0][0])，才是1种情况，其余都是0

4.填表顺序

从上往下填表，每一行从左往右

5.返回值

dp[m][n]

3.算法代码

class Solution {
public:
    int numDistinct(string s, string t) 
    {
        int m = t.size(), n = s.size();
        s = " " + s, t = " " + t;
        //1.创建dp表
        vector<vector<int>> dp(m+1, vector<int>(n+1));
        //2.初始化
        for(int j = 0; j <= n; j++) 
            dp[0][j] = 1;
        //3.填表
        for(int i = 1; i <= m; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                dp[i][j] += (dp[i][j-1] % (1000000000 + 7));
                if(t[i] == s[j])
                    dp[i][j] += (dp[i-1][j-1] % (1000000000 + 7));
            }
        }
        //4.返回值
        return dp[m][n] % (1000000000 + 7);
    }
};

四、通配符匹配

44. 通配符匹配 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/wildcard-matching/1.题目解析

给定s串和p串，问p串是否能和s串完全匹配

匹配规则：

1.'?'可以匹配任意单个字符

2.'*'可以匹配任意字符序列(多个字符, 包括空字符串也能匹配)

3.其他字符一一对应即可

eg:   s = "abcdef"   p = "*a*f"

这两个字符串就是可以匹配的，让第二个字符串的'*'匹配空串，'a'匹配'a', '*'匹配"bcde", 'f'匹配'f'即可

2.算法分析

1.状态表示

dp[i][j]: p[0, j] 区间内的子串是否能匹配 s[0, i] 区间内的子串
2.状态转移方程

上图是根据最后一个位置的状态划分问题得到的状态转移方程，但显然p[j]=='*'时，还需要一层for循环求解, 因此时间复杂度是O(N^3),  因此我们可以进一步优化, 将p[j]=='*'时的状态转移方程用若干个有限的状态表示

3.初始化

添加一行一列

dp[0][0] = true, 因为两个空串是匹配的

第一行的其他元素: 

第一行是i = 0, 表示s串是空串，而p串不是空串，因此想要p串匹配s串，p串必须全为连续的'*'字符。 所以写一个for循环，j遍历，当p[j]是'*'时， dp表的该位置是true, 否则后续全为false

第一列的其他元素:

p串为空，s串不为空，无法匹配， 值为false

4.填表顺序

从上往下填表，每一行从左往右

5.返回值

dp[m][n]

3.算法代码

class Solution {
public:
    bool isMatch(string s, string p) 
    {
        int m = s.size(), n = p.size();
        s = "_" + s, p = "_" + p;
        //1.创建dp表
        vector<vector<bool>> dp(m+1, vector<bool>(n+1));
        //2.初始化
        dp[0][0] = true;
        for(int j = 1; j <= n; j++)
            if(p[j] == '*') dp[0][j] = true;
            else break;
        //3.填表
        for(int i = 1; i <= m; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                if(p[j] == '*') 
                    dp[i][j] = dp[i][j-1] || dp[i-1][j];
                else 
                    dp[i][j] = (p[j] == '?' || s[i] == p[j]) && dp[i-1][j-1];
            }
        }
        //4.返回值
        return dp[m][n];
    }
};

五、正则表达式匹配

10. 正则表达式匹配 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/regular-expression-matching/1.题目解析

给定s串和p串，请你判断s串和p串是否能匹配

匹配规则:

1.'.'匹配任意单个字符

2.'*'要结合前面的一个字符来解析，比如"a*"可以表示空串，可以表示a, 可以表示aa, 可以表示aaa等等

3.'*'前面如果还是一个'*',  是无效的，因为无法被解析, 题目保证了不会出现这种情况

题目保证了字符串中只有小写字母和'.'与'*'

2.算法分析

1.状态表示

dp[i][j]: p[0, j] 区间内的子串是否能匹配 s[0, i] 区间内的子串

2.状态转移方程

3.初始化

添加一行一列

dp[0][0] = true, 因为两个空串是匹配的

第一行的其他元素: 

第一行是i = 0, 表示s串是空串，而p串不是空串，因此想要p串匹配s串: p串必须是:

_*_*_*的形式，假如第一个位置是1，也就是要求连续的偶数位置都是*, 此时才能匹配，当某一个偶数为不是*了，后续的dp值都是false

第一列的其他元素:

p串为空，s串不为空，无法匹配， 值为false

4.填表顺序

从上往下填表，每一行从左往右

5.返回值

dp[m][n]

3.算法代码

class Solution {
public:
    bool isMatch(string s, string p) 
    {
        int m = s.size(), n = p.size();
        s = "_" + s, p = "_" + p;
        //1.创建dp表
        vector<vector<bool>> dp(m+1, vector<bool>(n+1));
        //2.初始化
        dp[0][0] = true;
        for(int j = 2; j <= n; j += 2)
            if(p[j] == '*') dp[0][j] = true;
            else break;
        //3.填表
        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] = (p[j] == s[i] || p[j] == '.') && dp[i-1][j-1];
            }
        }
        //4.返回值
        return dp[m][n];
    }
};

六、交错字符串

97. 交错字符串 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/interleaving-string/1.题目解析

给定字符串s1, s2, s3, 判断s1和s2能否交错构成s3

2.算法分析

先预处理一下，将三个字符串的前面加上'_'

1.状态表示

dp[i][j]: s1中 [1, i] 区间内的字符串以及 s2[1, j] 区间内的字符串，能拼接成 s3[1, i+j] 区间内的字符串

2.状态转移方程

3.初始化

dp[0][0] = true, 表示两个空串可以拼接成空串

第一行的其余位置：

s1为空，s2不为空，所以当s2对应位置字符和s3对应位置字符相等时，就是true, 某个位置不相等，则后续的dp值都是false

第一列的其余位置：

s2为空，s1不为空，所以当s1对应位置字符和s3对应位置字符相等时，就是true, 某个位置不相等，则后续的dp值都是false

4.填表顺序

从上往下填表，每一行从左往右

5.返回值

dp[m][n]

3.算法代码

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) 
    {
        //1.创建dp表
        int m = s1.size(), n = s2.size();
        if(m + n != s3.size()) return false; //s1长度+s2长度 != s3长度，直接返回false
        s1 = " " + s1, s2 = " " + s2, s3 = " " + s3;
        vector<vector<bool>> dp(m+1, vector<bool>(n+1));
        //2.初始化dp表
        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;
        //3.填表
        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]);
        //4.返回值
        return dp[m][n];
    }
};

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

712. 两个字符串的最小ASCII删除和 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/minimum-ascii-delete-sum-for-two-strings/description/1.题目解析

给定两个字符串，每个字符串都可以删除若干字符，删除之后使得两个字符串相等，求删除的字符的最小的ASCII值之和

2.算法分析

正难则反: 求两个字符串里面的所有公共子序列里面，ASCII值的最大和

1.状态表示

dp[i][j]: s1的 [0, i] 区间以及 s2的 [0, j] 区间内的所有子序列里，公共子序列的ASCII的最大和

2.状态转移方程

3.初始化

添加一行一列, 全都初始化0，因为任何一个字符串为空，公共子序列的ASCII之和都是空
4.填表顺序

从上往下填表，每一行从左往右

5.返回值

两个字符串的ASCII之和 - dp[m][n] * 2

3.算法代码

class Solution {
public:
    int minimumDeleteSum(string s1, string s2) 
    {
        //1.创建dp表 + 初始化
        int m = s1.size(), n = s2.size();
        s1 = " " + s1, s2 = " " + s2;
        vector<vector<int>> dp(m+1, vector<int>(n+1));
        //2.填表
        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] == s2[j])
                    dp[i][j] = max(dp[i][j], dp[i-1][j-1] + s1[i]);
            }
        }
        //3.返回值
        int sum = 0;
        for(int i = 1; i <= m; i++)
            sum += s1[i];
        for(int j = 1; j <= n; j++)
            sum += s2[j];
        return sum - dp[m][n] * 2;
    }
};

八、最长重复子数组

718. 最长重复子数组 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/maximum-length-of-repeated-subarray/1.题目解析

找出两个数组中的最长重复子数组， 返回长度

2.算法分析

1.状态表示

dp[i][j]: nums1中以 i 位置元素为结尾的所有子数组以及nums2中以 j 位置元素为结尾的所有子数组中，最长重复子数组的长度

2.状态转移方程

3.初始化

添加一行一列,全部初始化成0(因为任何一个子数组为空，最长重复子数组长度就是0)

4.填表顺序

从上往下填表

5.返回值

dp表的最大值

3.算法代码
 

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) 
    {
        //1.创建dp表
        int m = nums1.size(), n = nums2.size();
        vector<vector<int>> dp(m+1, vector<int>(n+1));
        //2.填表
        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]);
            }
        }
        //3.返回值
        return ret;
    }
};

编程之路，妙趣横生
关注
  • 16
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法基础——动态规划之最大子数组问题
qq_36445477的博客
04-08 888
问题描述 - 分而治之的解决方案 在分治算法中，已经学习过最大子数组问题。使用分治的方法：将大数组arr分为两个小数组arr_left和arr_right，则求解arr的最大子数组和等价于： 在arr_left的最大子数组和、arr_right的最大子数组和、跨中点的最大子数组和中找一个最大的，即为arr的最大子数组和。 采用分治算法解决该问题，Golang实现在前面分治的博客里写过，其时间...
01背包问题动态规划，背包问题介绍算法实现
01-21
动态规划是解决这类问题的有效方法，因为它能够避免重复计算，通过构建一个二维数组来存储中间结果。 问题描述： 在01背包问题中，我们有一组物品，每个物品具有特定的重量`wt[i]`和价值`val[i]`，以及一个背包，其...
动态规划-两个数组的dp问题2
qq_45965652的博客
05-07 798
动态规划中两个数组的dp问题的简单总结2。
动态规划-两个数组的dp问题3
qq_45965652的博客
05-14 869
动态规划中两个数组的dp问题简单总结3。
动态规划：两个数组的dp问题（C++）
2301_76269963的博客
10-01 1995
动态规划：两个数组的dp问题（C++）
动态规划-二维dp数组和滚动数组
ZiYueShengXian的博客
08-31 2379
二维数组 如上图,一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 问总共有多少条不同的路径？ 看到这道题,查找从A点到B点的路径,如果对图论比较熟悉的话,可能第一印象是用图论的深度优先搜索来实现. func dfs(i int, j int, m int, n int) int { if i > m || j > n { return 0
【动态规划】C++ dp子数组问题（最大/最长：环形/子数组和、乘积最大/为正数、单词拆分、子串）
卜及中的博客
04-22 873
文章介绍了子数组类的dp问题，并通过一系列算法题加深对该类问题的解法理解。
从01背包开始动态规划：暴力解法 + dp + 滚动数组 + dp优化
Villanelle_w的博客
03-22 1006
如何直接将滚动数组的g删去，会导致 f 的更新错误，因为在更新 f [ j ] 时，f [ j - v [ i ] ] 已经更新过，也就是他在第 i 层，而更新时需要的是第 i - 1 层的数据，如下图：（下两图来源于b站up，一只会code的小金鱼）本题用两个数组来存储，其中 f 在更新前（memcpy(f , g , sizeof f)）表示第 i - 1层的数，而 g 表示第i层的数，每一层完成后，对 f 进行更新。不选时，f [ i ] [ j ] 不变。方法四：dp优化，用一个数组存储。
算法复习——动态规划篇之最大子数组问题
NickHan_cs的博客
01-25 2622
算法复习——动态规划篇之最大子数组问题 以下内容主要参考中国大学MOOC《算法设计与分析》，墙裂推荐希望入门算法的童鞋学习！ 1. 问题背景 子数组：数组中连续的一段序列，例如X[3..7]X[3..7]X[3..7]； 子数组和：子数组中元素的求和，X[3..7]X[3..7]X[3..7]的和就是3+5−4+3+2=93+5-4+3+2=93+5−4+3+2=9； ​ 那么，问题就是如何寻找数组XXX中最大的非空子数组？ 2. 问题定义 最大子数组问题（Max Continuous Subarr
背包问题-DP动态规划
weixin_74092648的博客
03-10 1061
01背包问题 题目 思路 代码 01背包问题的最优方案 题目 思路 代码 完全背包问题 题目 思路 代码
动态规划专题——背包问题
热门推荐
⚡
02-13 3万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
C#，动态规划的集合划分问题（DP Partition problem）算法与源代码
04-25
动态规划问题中的划分问题是确定一个给定的集是否可以划分为两个子集，使得两个子集中的元素之和相同。 动态规划（Dynamic Programming，DP）是运筹学的一个分支，是求解决策过程最优化的过程。20世纪50年代初，...
01背包问题动态规划.md
04-10
"01背包问题"是一个经典的动态规划问题。在这个问题中，我们有一组物品，每个物品都有自己的重量和价值。我们还有一个背包，它有一个最大承重限制。我们的目标是选择一些物品放入背包中，使得背包内物品的总价值最大...
使用动态规划算法解决背包问题.pdf
11-14
具体而言，我们用两个嵌套的循环来遍历所有可能的子问题。对于每个子问题，我们比较选择当前物品和不选择当前物品两种情况下的最大价值，并将较大值存储在对应的`dp`数组位置中。最后，`dp[n][W]`即为问题的最优解，...
数组分割问题(印象深刻)1
08-08
数组分割问题是一种经典的动态规划问题，旨在将一个无序的正整数数组分割为两个子数组，使得两个子数组之和最接近。该问题可以拆分为两个子问题：一是将数组分割为两个元素个数不限的子数组，使得两个子数组之和最...
算法篇-二叉树
分享Java知识，记录思考和感悟
06-21 283
分享二叉树相关概念和算法题
LeetCode 算法：排序链表 c++
最新发布
小金牛来了
06-22 554
LeetCode 算法：排序链表 c++
【康复学习--LeetCode每日一题】2748. 美丽下标对的数目
Puppet__的博客
06-20 384
如果下标对 i、j 满足 0 ≤ i < j < nums.length ，如果 nums[i] 的 第一个数字 和 nums[j] 的 最后一个数字 互质 ，则认为 nums[i] 和 nums[j] 是一组 美丽下标对。2 和 5 互质，因此 gcd(2,1) == 1。i = 1 和 j = 2 ：nums[1] 的第一个数字是 5 ，nums[2] 的最后一个数字是 1。i = 0 和 j = 1 ：nums[0] 的第一个数字是 1 ，nums[1] 的最后一个数字是 1。
华为OD机试C卷（100分）-最大N个数与最小N个数的和（C语言）
欢迎来到我的博客~
06-16 214
给定一个数组，编写一个函数来计算它的最大N个数与最小N个数的和。你需要对数组进行去重。说明 最大2个数[100,95],最小2个数[83,64], 输出为342。说明 最大2个数[4,3],最小2个数[3,2], 有重叠输出为-1。最大N个数与最小N个数不能有重叠，如有重叠，输入非法返回-1。第三行输入N，N表达需要计算的最大、最小N个数。数组中数字范围[0, 1000]第一行输入M， M标识数组大小。第二行输入M个数，标识数组内容。输出最大N个数与最小N个数的和。
C语言动态规划求两个数组最长公共连续子序列
03-29
以下是C语言实现动态规划求两个数组最长公共连续子序列的代码： ```c #include #include int lcs(int* arr1, int* arr2, int m, int n) { int** dp = (int**)malloc((m+1)*sizeof(int*)); for (int i = 0; i ;...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值