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

最新推荐文章于 2024-06-19 08:00:00 发布
最新推荐文章于 2024-06-19 08:00:00 发布
阅读量993 收藏 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
    评论
专栏目录
01背包问题动态规划，背包问题介绍算法实现
01-21
动态规划是解决这类问题的有效方法，因为它能够避免重复计算，通过构建一个二维数组来存储中间结果。 问题描述： 在01背包问题中，我们有一组物品，每个物品具有特定的重量`wt[i]`和价值`val[i]`，以及一个背包，其...
C#，动态规划的集合划分问题（DP Partition problem）算法与源代码
04-25
动态规划问题中的划分问题是确定一个给定的集是否可以划分为两个子集，使得两个子集中的元素之和相同。 动态规划（Dynamic Programming，DP）是运筹学的一个分支，是求解决策过程最优化的过程。20世纪50年代初，...
动态规划-两个数组的dp问题2
qq_45965652的博客
05-07 797
动态规划中两个数组的dp问题的简单总结2。
动态规划-两个数组的dp问题3
qq_45965652的博客
05-14 865
动态规划中两个数组的dp问题简单总结3。
动态规划：两个数组的dp问题（C++）
2301_76269963的博客
10-01 1986
动态规划：两个数组的dp问题（C++）
动态规划-二维dp数组和滚动数组
ZiYueShengXian的博客
08-31 2376
二维数组 如上图,一个机器人位于一个 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 870
文章介绍了子数组类的dp问题，并通过一系列算法题加深对该类问题的解法理解。
01背包问题动态规划.md
04-10
"01背包问题"是一个经典的动态规划问题。在这个问题中，我们有一组物品，每个物品都有自己的重量和价值。我们还有一个背包，它有一个最大承重限制。我们的目标是选择一些物品放入背包中，使得背包内物品的总价值最大...
使用动态规划算法解决背包问题.pdf
11-14
具体而言，我们用两个嵌套的循环来遍历所有可能的子问题。对于每个子问题，我们比较选择当前物品和不选择当前物品两种情况下的最大价值，并将较大值存储在对应的`dp`数组位置中。最后，`dp[n][W]`即为问题的最优解，...
动态规划-TSP.doc
06-30
动态规划解决 TSP 问题 动态规划是一种非常重要的算法思想，在解决复杂问题时非常有用。本次实验主要解决了旅行商问题（TSP），即一个旅行商人要拜访 n 个城市，他必须选择所要走的路径，路径的限制是每个城市只能...
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 452
【代码】力扣LCP 08.剧情触发时间。
算法训练营day60
stmfresher的博客
06-16 223
【代码】算法训练营day60。
算法体系-20 第二十节暴力递归到动态规划
m0_61164038的博客
06-12 342
四种模型和体系班两种模型一共六种模型0.1 从左往右模型0.2 范围讨论模型范围尝试模型 （这种模型特别在乎讨论开头如何如何 结尾如何如何）玩家博弈问题，玩家玩纸牌只能那左或者右0.3 样本对应样本对应模型（特别在乎两个样本结尾如何如何 最长公共子序列）0.4 业务限制模型动态规划只是暴力尝试的一个缓存。
算法体系-19 第十九节 暴力递归到动态规划
m0_61164038的博客
06-11 306
一旦写出递归来，改动态规划就很快尝试策略和状态转移方程是一码事学会尝试是攻克动态规划最本质的能力如果你发现你有重复调用的过程，动态规划在算过一次之后把答案记下来，下回在越到重复调用过程就直接调做题思路 一定要从尝试入手动态规划的套路从尝试出发,从尝试递归出发，然后在改动态规划的时候第一步找到base的情况填上相应位置的数，然后根据下一步的条件推出其他位置的数；
leetcode刷题记录40-886. 可能的二分法
xianduan_的博客
06-14 340
二分图问题，从我学到的知识，应该主动将其理解成双色问题。就是用两种颜色来对图上色，如果最后能形成二分图，则满足题目要求。每个人都可能不喜欢其他人，那么他们不应该属于同一组。当可以用这种方法将所有人分进两组时，返回。）， 我们想把每个人分进。，表示不允许将编号为。
LeetCode 算法：螺旋矩阵c++
小金牛来了
06-11 1480
LeetCode 算法：螺旋矩阵c++
6-11 函数题：某范围中的最小值
qq_2937655951的博客
06-13 455
6-11 函数题：某范围中的最小值 分数 5 作者 雷丽兰 单位 宜春学院 有n(n
深入理解指针（二）
黎相思的技术博客
06-13 1161
上面的代码虽然可以完成我们的需求,但是还是不够好,加入是1,2,3,4,5,6,7,8,9,10这样的数字呢?数组传参的时候,形参可以写成数组,也可以写成指针,数组传参的本质是传递的首元素的地址,所以形参即使写成数组的形式,本质上也是一个指针变量。数组首元素的地址和整个数组它们的地址是一样的,就说明它们的起始位置是一样的,那么arr和&arr的地址一样,本质上有啥区别呢?,这⾥的数组名表示整个数组,取出的是整个数组的地址(整个数组的地址和数组首元素的地址是有区别的)。
堆优化版Dijkstra求最短路-java
最新发布
m0_63267251的博客
06-19 918
主要通过堆优化Dijkstra算法解决最短路，可以跟朴素版的Dijkstra算法进行对比。
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、付费专栏及课程。

余额充值