两个数组的dp问题

已于 2024-08-22 19:31:26 修改
阅读量1.8k 收藏 72
点赞数 113
分类专栏： 算法 文章标签： 算法 动态规划
于 2024-07-22 00:46:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmh_1234567/article/details/140308493
版权

目录

最长公共子序列

不相交的线

不同的子序列

通配符匹配

正则表达式匹配

交错字符串

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

最长重复子数组

声明：接下来主要使用动态规划来解决问题！！！

最长公共子序列

题目

思路

根据经验+题目要求，我们将屡试不爽的采用“以某个位置”为结尾来分析问题。

状态表示：dp[i][j]表示字符串1的[0,i]区间和字符串2的[0,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]).

初始化：不用初始化。

填表顺序：从左往右。

返回值：dp[m][n].

代码

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 longestCommonSubsequence(string text1, string text2) {
        int m=text1.size(),n=text2.size();
        vector<vector<int>> dp(m+1,vector<int>(n+1));
        text1=' '+text1;
        text2=' '+text2;
        for(int i=1;i<=m;i++)
            for(int j=1;j<=n;j++){
                if(text1[i]==text2[j]) 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为例，

通过观察不难发现，实则是找两个数组的最长公共子数组，与上一道题最长公共子序列如出一辙。

根据经验+题目要求，我们将屡试不爽的采用“以某个位置”为结尾来分析问题。

状态表示：dp[i][j]表示数组1的[0,i]区间和数组2的[0,j]区间内的所有公共子数组的最长的长度.

状态转移方程：if(nums1[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]).

初始化：不用初始化。

填表顺序：从左往右。

返回值：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,i]区间内有多少种t[0,j]区间字符串。

状态转移方程：dp[i][j]=dp[i-1][j]+dp[i-1][j-1]【后者必须满足s[i]==t[j]】

初始化：dp[i][0]=1,第一列全都初始化为1.

返回值：dp[m][n].

代码

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




//或者下面的代码




class Solution {
public:
    int numDistinct(string s, string t) {
        int m=s.size(),n=t.size();
        s=' '+s;
        t=' '+t;
        vector<vector<double>> dp(m+1,vector<double>(n+1));
        for(int i=0;i<=m;i++)
            dp[i][0]=1;
        for(int i=1;i<=m;i++)
            for(int j=1;j<=n;j++){
                dp[i][j]=dp[i-1][j];
                if(s[i]==t[j])
                    dp[i][j]+=dp[i-1][j-1];
            }
        return dp[m][n];
    }
};
通配符匹配

题目

思路

根据经验+题目要求，我们将屡试不爽的采用“以某个位置”为结尾来分析问题。

状态表示：dp[i][j]表示字符串p[0,j]区间字符串是否能匹配字符串s[0,i]区间字符串。

针对p[j]=='*'，化简

【1】数学方法

【2】分析法

可以先让'*’匹配一个s字符串末尾字符，但是不消掉'*'

得

状态转移方程：

                if(p[j-1]!='*') dp[i][j]=(p[j-1]=='?' || p[j-1]==s[i-1]) && dp[i-1][j-1];

                else dp[i][j]=dp[i-1][j] || dp[i][j-1];

初始化：

第一列除去[0,0]位置之外全都为fasle,

第一行除去[0,0]位置之外，初始化规则：当字符串p[0,j]区间含不为'*'字符，后边都为false，否则为true.

填表顺序：从上往下，从左往右。

返回值：dp[m][n].

代码

class Solution {
public:
    bool isMatch(string s, string p) {
        int m=s.size(),n=p.size();
        vector<vector<bool>> dp(m+1,vector<bool>(n+1));
        dp[0][0]=true;
        for(int i=1;i<=n;i++){
            if(p[i-1]=='*') dp[0][i]=true;
            else break;
        }
        for(int i=1;i<=m;i++)
            for(int j=1;j<=n;j++){
                if(p[j-1]!='*') dp[i][j]=(p[j-1]=='?' || p[j-1]==s[i-1]) && dp[i-1][j-1];
                else dp[i][j]=dp[i-1][j] || dp[i][j-1];
            }
        return dp[m][n];
    }
};



//或者为下面的代码



class Solution {
public:
    bool isMatch(string s, string p) {
        int m=s.size(),n=p.size();
        vector<vector<bool>> dp(m+1,vector<bool>(n+1));
        // dp[0][0]=true;
        for(int i=0;i<=n;i++){
            bool flag=true;
            for(int j=0;j<i;j++){
                if(p[j]!='*') flag=false;
            }
            dp[0][i]=flag;
        }
        for(int i=1;i<=m;i++)
            for(int j=1;j<=n;j++){
                if(p[j-1]==s[i-1]) dp[i][j]=dp[i-1][j-1];
                else if(p[j-1]=='?') dp[i][j]=dp[i-1][j-1];
                else if(p[j-1]=='*') dp[i][j]=dp[i-1][j] || dp[i][j-1];
            }
        return dp[m][n];
    }
};
正则表达式匹配

题目

思路

根据经验+题目要求，我们将屡试不爽的采用“以某个位置”为结尾来分析问题。

状态表示：dp[i][j]表示字符串p[0,j]区间字符串是否能匹配字符串s[0,i]区间字符串。

针对p[j]=='*'，化简

【1】数学方法

【2】分析法

可以先让'*’和前一个字符匹配一个s字符串末尾字符，但是不消掉'*'和前一个字符

状态转移方程：

                if(p[j-1]=='*') dp[i][j]=((p[j-2]==s[i-1] || p[j-2]=='.') && dp[i-1][j]) || dp[i][j-2];

                else dp[i][j]=(p[j-1]=='.' || p[j-1]==s[i-1]) && dp[i-1][j-1];

初始化：

第一列除去[0,0]位置之外全都为fasle,

第一行除去[0,0]位置之外，初始化规则：当字符串p[0,j]区间偶数位置都为'*'字符，则为false，其余位置为false，否则之后都为true.

填表顺序：从上往下，从左往右。

返回值：dp[m][n].

代码

class Solution {
public:
    bool isMatch(string s, string p) {
        int m=s.size(),n=p.size();
        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-1]=='*') dp[0][i]=true;
            else break;
        }
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                if(p[j-1]=='*') dp[i][j]=((p[j-2]==s[i-1] || p[j-2]=='.') && dp[i-1][j]) || dp[i][j-2];
                else dp[i][j]=(p[j-1]=='.' || p[j-1]==s[i-1]) && dp[i-1][j-1];
            }
        }
        return dp[m][n];
    }
};




//或者为下面的代码




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]=((p[j-1]==s[i] || p[j-1]=='.') && dp[i-1][j]) || dp[i][j-2];
                else dp[i][j]=(p[j]=='.' || p[j]==s[i]) && dp[i-1][j-1];
            }
        }
        return dp[m][n];
    }
};
交错字符串

题目

思路

根据经验+题目要求，我们将屡试不爽的采用“以某个位置”为结尾来分析问题。

为了便于表述，在s1,s2,s3每个字符串的最前边增加一个空格。

状态表示：dp[i][j]表示字符串s1[1,i]区间和字符串s2[1,j]区间能否凑成字符串s3的[1,i+j]区间。

状态转移方程：

初始化：

初始化第一行规则：依次判断字符串s2和s3对应位置是否相等，相等则为true，否则为false并break.

初始化第一列规则：依次判断字符串s1和s3对应位置是否相等，相等则为true，否则为false并break.

填表顺序：从上往下，从左往右。

返回值：dp[m][n]。

代码

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));
        for(int i=0;i<=m;i++)
            if(s1[i]==s3[i]) dp[i][0]=true;
            else break;
        for(int i=0;i<=n;i++)
            if(s2[i]==s3[i]) dp[0][i]=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删除和，若直接求两个字符串的最小ASCII删除和有点麻烦，采用“正难则反”的思想，由于字符串时确定的，即两个字符串的ASCII值总和是确定的，那么只需要求出两个字符串的所有公共子序列中ASCII值最大的子序列，用sum-2*公共子序列ASCII最大值即可。

状态表示：dp[i][j]表示字符串s1[0,i]区间和字符串s2[0,j]区间所有的公共子序列中ASCII总和最大的值。

状态转移方程：

                dp[i][j]=max(dp[i][j-1],dp[i-1][j]);

                if(s1[i-1]==s2[j-1])

                    dp[i][j]=max(dp[i][j],dp[i-1][j-1]+s1[i-1]);

初始化：不用初始化。

填表顺序：从上往下，从左往右。

返回值：ret-2*dp[m][n]。

代码

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));
        int ret=0;
        for(char ch:s1)
            ret+=ch;
        for(char ch:s2)
            ret+=ch;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                dp[i][j]=max(dp[i][j-1],dp[i-1][j]);
                if(s1[i-1]==s2[j-1]) 
                    dp[i][j]=max(dp[i][j],dp[i-1][j-1]+s1[i-1]);
            }
        }
        return ret-2*dp[m][n];
    }
};
最长重复子数组

题目

思路

根据经验+题目要求，我们将屡试不爽的采用“以某个位置”为结尾来分析问题。

如果以区间来分析问题，仔细分析一下会发现是错误的，因为子数组是连续的，而子序列可以连续也可以不连续，那么我们将以某个位置为结尾来分析问题。

状态表示：dp[i][j]表示数组nums1[0,i]和数组nums2[0,j]区间的所有重复子数组中的最长的长度。

状态转移方程：

初始化：不用初始化。

填表顺序；从上往下，从左往右。

返回值：dp表最大值。

代码

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;
    }
};

新绿MEHO
关注
专栏目录
DP：两个数组的dp问题
weixin_51142926的博客
06-14 1528
字符串dp技巧：空串是有研究意义的，引入空串可以帮助我们思考虚拟的边界如何进行初始化。
DP：子数组问题
2301_79969994的博客
07-01 1235
简要介绍什么是子数组问题，以及这些问题在实际应用中的重要性。例如，最大子数组和问题、最长递增子数组问题等。通过本文的介绍，我们详细探讨了动态规划在解决子数组问题中的应用，具体分析了最大子数组和问题和最长递增子数组问题。这些问题在实际生活中的数据处理、优化等场景中有着广泛的应用。动态规划通过将问题分解为子问题，保存子问题的解，避免了重复计算，从而大大提高了算法的效率。在学习和应用动态规划的过程中，我们需要明确状态、状态转移方程和初始条件。通过练习具体问题，我们可以更深入地理解动态规划的思想和方法。
动态规划-两个数组的dp问题2
qq_45965652的博客
05-07 892
动态规划中两个数组的dp问题的简单总结2。
【动态规划六】两个数组的dp问题
m0_74126249的博客
05-20 1114
上图是根据最后一个位置的状态划分问题得到的状态转移方程，但显然p[j]=='*'时，还需要一层for循环求解, 因此时间复杂度是O(N^3), 因此我们可以进一步优化, 将p[j]=='*'时的状态转移方程用若干个有限的状态表示。dp[i][j]: s1中 [1, i] 区间内的字符串以及 s2[1, j] 区间内的字符串，能拼接成 s3[1, i+j] 区间内的字符串。这两个字符串就是可以匹配的，让第二个字符串的'*'匹配空串，'a'匹配'a', '*'匹配"bcde", 'f'匹配'f'即可。
动态规划算法专题（七）：两个数组的dp问题
2401_83595513的博客
10-15 1636
DP(七)_根据最后一个位置的状况，划分问题
动态规划课堂7-----两个数组的dp问题（等价代换）
2301_80035594的博客
03-21 2338
详细介绍了动态规划中的两数组问题，先给出常见分析思路和解题过程，再给出例题和详细解析帮助理解这类问题，文中所有例题分析思路均采用模板，代码均经过检验，希望能帮助到你。
动态规划-两个数组的dp问题3
qq_45965652的博客
05-14 967
动态规划中两个数组的dp问题简单总结3。
【DP】将一个数组分为两个数组，使两个数组和的差最小
菜菜鸟的博客
03-02 2261
/* 将一个数组分为两个数组，使两个数组和的差最小 */ public class SplitArray{ public int diff(int[] array){ int sum = 0; for(int i=0; i<array.length; i++){ sum += array[i]; } ...
求两个数组元素相乘和（区间dp）
blaze_jack
06-20 1199
给定两个数组x,y，每次从数组x顺序取一个数a，从数组y的头或者尾巴取一个数b，求所有a*b的最大和。 举例说明： 数组 x
动态规划：两个数组的dp问题（C++）
2301_76269963的博客
10-01 2253
动态规划：两个数组的dp问题（C++）
礼物的最大价值（二维数组 dp）1
08-03
它通过两个嵌套的循环遍历整个棋盘，填充 dp 数组，并最终返回右下角的值，即最大价值。 例如，对于输入的二维数组： ``` [ [1, 3, 1], [1, 5, 1], [4, 2, 1] ] ``` 我们可以得到以下 dp 数组： ``` [ [1, 4...
DP-LeetCode152. 乘积最大子数组（Python）
12-21
这个问题可以通过动态规划（Dynamic Programming, DP）来解决。这里我们将分析两种不同的Python解题方法。 **方法一：二维数组法** 这种方法的核心思想是利用一个2x2的二维数组`dp`来存储子数组的最大值和负最大值...
【面试题记】查找两个数组的最大公共子数组
wuliytTaotao的博客
07-14 534
问题描述： 查找两个数组的最大公共子数组，要求返回的子数组是连续的。如输入：`A = [3,1,3,2,1,4], B = [3,2,3,2,1,4]`，输出：`[3,2,1,4]`。
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 391
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
xtu oj 连接字符串
Go offline for a while
10-30 959
最后总结一下：这题思路比较直观，找公共的元素，代码细节比较多，一个是要求输出字典序小的，第二是前面字符串要枚举完最后一个元素才算满足条件，第三是两个字符串可能完全没有公共部分，需要特判。
【力扣打卡系列】二分查找(搜索旋转排序数组)
qq_45734745的博客
10-29 290
坚持按题型打卡&刷&梳理力扣算法题系列，语言为go，Day11。
【算法】Kruskal最小生成树算法
Eristic0618的博客
10-29 718
算法学习笔记之Kruskal最小生成树算法
迷宫求解：探索最优路径的算法与应用
最新发布
liaozp88的博客
11-02 110
迷宫求解问题通常可以通过图搜索算法来解决，常用的方法包括广度优先搜索（BFS）、深度优先搜索（DFS）和A*算法。
【力扣打卡系列】二分查找（搜索旋转排序数组2）
qq_45734745的博客
10-29 260
坚持按题型打卡&刷&梳理力扣算法题系列，语言为go，Day10。
求解一个整数数组划分为两个子数组问题
03-16
好的，我理解你的问题是要求将一个整数数组分成两个子数组，使得这两个子数组的元素之和相等，对吧？ 这是一个经典的问题，被称为“数组分割问题”（Array Partition Problem）。这个问题可以用动态规划（Dynamic Programming）算法来解决。 具体来说，我们可以先计算出整个数组的元素之和 sum，然后尝试在数组中选择一些元素，使得它们的元素之和为 sum/2。如果能找到这样的一组元素，那么剩下的元素就组成另一个子数组，这两个子数组的元素之和就相等了。 为了实现这个算法，我们可以用一个二维的布尔型数组 dp，其中 dp[i][j] 表示在前 i 个元素中是否存在一些元素的元素之和为 j。具体的状态转移方程如下： dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]] 其中 nums 是原数组，dp[i][j] 表示选或不选第 i 个元素。 最终，如果存在 dp[n][sum/2] 为 true，那么就可以分成两个子数组，否则就不能。 以下是这个算法的 Python 代码实现： ```python def can_partition(nums): n = len(nums) total_sum = sum(nums) if total_sum % 2 != 0: return False target_sum = total_sum // 2 dp = [[False] * (target_sum + 1) for _ in range(n)] for i in range(n): dp[i][0] = True for j in range(1, target_sum + 1): if nums[0] == j: dp[0][j] = True for i in range(1, n): for j in range(1, target_sum + 1): if j < nums[i]: dp[i][j] = dp[i-1][j] else: dp[i][j] = dp[i-1][j] or dp[i-1][j-nums[i]] return dp[n-1][target_sum] ``` 希望对你有所帮助！
评论 99
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

新绿MEHO

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值