代码随想录打卡第37天：动态规划解决子序列问题2

于 2024-05-22 20:07:43 发布
阅读量1k 收藏 8
点赞数 18
分类专栏： 代码随想录训练营打卡 文章标签： 动态规划 算法 leetcode 学习 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mooc666quq/article/details/139127403
版权

1.1143最长公共子序列

1.问题描述

找到其中最长公共子序列的长度。

2.问题转换

按照顺序遍历，找到相同的字符，则长度+1

3.解题思路

  1. 每一个位置的text1[i]和text2[j]都有两种状态：是否相等
  2. 如果相等：代表长度在text1[0..i-1],text2[0..j-1]的基础上+1
  3. 如果不相等，代表长度保持不变

4.为什么使用动态规划？

因为每一个位置的状态都能由前面的状态递推出来

5.动态规划的具体实现

  1. dp[i][j]数组的含义：代表的是从text1[0..i-1]text2[0..j-1]的最长公共子序列。
  2. 递推公式：

    if(text1[i-1] == text2[j-1]){

                        dp[i][j] = dp[i-1][j-1]+1;

                    }else{

                        dp[i][j] = max(dp[i][j-1],dp[i-1][j]);//如果不等就选择其中较大的

                    }

  3. 初始化：初始化为0，需要注意的是这里dp[i][0]和dp[0][j]是没有实际意义的，但是可以保证我们可以满足后续的递推能够正常进行。
  4. 遍历顺序：由递推公式可以知道，应该是从上到下，从左到右的遍历顺序。
class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int m = text1.size();
        int n = text2.size();
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));//dp[i][j]:0-i-1,0-j-1的最长公共子序列
        for(int i = 1;i<m+1;i++){
            for(int j = 1;j<n+1;j++){
                if(text1[i-1] == text2[j-1]){
                    dp[i][j] = dp[i-1][j-1]+1;
                }else{
                    dp[i][j] = max(dp[i][j-1],dp[i-1][j]);
                }
                //cout<<dp[i][j]<<" ";
            }
            //cout<<endl;
        }
        return dp[m][n];
    }
};

2.1035不相交的线

不相交的线和最长的公共子序列抽象出来的方法都是一样的，都是为了求解最长公共子序列，所以在这里不做讨论，直接看前面即可。

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        int m = nums1.size();
        int n = nums2.size();
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));//dp[i][j]代表的是从0-i，0-j之间的最大的不相交的个数
        //属于是组合问题
        for(int i = 1;i<m+1;i++){
            for(int j = 1;j<n+1;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];
    }
};

3.392判断子序列

在前面最长公共子序列的前提下，只需要添加一个最后最长的长度是否等于短的那个即可判断是否是子序列，所以直接看第一个思路即可。

class Solution {
public:
    bool isSubsequence(string s, string t) {
        //第一种方法在前面的最长公共子序列上面改
        /*
        int m = s.size();
        int n = t.size();
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));//dp[i][j]:0-i-1,0-j-1的最长公共子序列
        for(int i = 1;i<m+1;i++){
            for(int j = 1;j<n+1;j++){
                if(s[i-1] == t[j-1]){
                    dp[i][j] = dp[i-1][j-1]+1;
                }else{
                    dp[i][j] = max(dp[i][j-1],dp[i-1][j]);
                }
                //cout<<dp[i][j]<<" ";
            }
            //cout<<endl;
        }
        return dp[m][n] == m;
        */
        //第二种方法：直接根据理论知识计算
        int m = s.size();
        int n = t.size();
        int i = 0,j = 0;
        int count = 0;
        for(;i<m;i++){
            for(;j<n;j++){
                if(s[i] == t[j]){
                    count++;
                    j++;
                    break;
                }
            }
        }
        return m == count;
    }
};

4.115不同的子序列

1.问题描述

找到其中出现的子序列的个数。

2.问题转换

对于出现多个能够匹配的位置，确定能够匹配的最多次数，累加。

3.解题思路

  1. 每一个位置的s[i]和t[j]都有两种状态：是否相等
  2. 如果相等：有两种情况：1.s[i]参与匹配。2.s[i]不参与匹配。（相等不一定代表这个值一定参与匹配）比如s =abbb ,t = ab,s[2] = t[1]，此时s[2]可以参与匹配，也可以不参与匹配，为两者的累加和
  3. 如果不相等：代表s[i]一定不参与匹配。

4.为什么使用动态规划？

因为每一个位置的状态都能由前面的状态递推出来

5.动态规划的具体实现

  1. dp[i][j]数组的含义：代表的是从s[0..i]t[0..j]能够匹配的个数。
  2. 递推公式： 
    if(s[i-1] == t[j-1]){
                    dp[i][j] = dp[i-1][j-1] +dp[i-1][j];//分两种情况，第一种是s[i-1]参与匹配，第二种是不参与匹配
                }else{
                    dp[i][j] = dp[i-1][j];
                }
  3. 初始化：dp[i][0]=1,因为我们可以通过删除s的数据，保证空字符串能够匹配
  4. 遍历顺序：由递推公式可以知道，应该是从上到下，从左到右的遍历顺序。
class Solution {
public:
    //i代表的是s对应的下标，j代表的是t的下标
    //思路：dp数组就是按照老惯例即可
    //对于相等情况的处理：需要注意的是分两种情况，即此时的s[i-1]是否参与的情况，s[i-1]不一定非要参与匹配，也有可能没参与匹配
    //初始化的时候需要注意的就是对边界的处理,如果t长度为0那么s一定可以匹配
    int numDistinct(string s, string t) {
        int m = s.size();
        int n = t.size();
        vector<vector<uint64_t>> dp(m+1,vector<uint64_t>(n+1,0));
        for(int i = 0;i<m+1;i++)dp[i][0] = 1;//很重要
        for(int j = 1;j<n+1;j++)dp[0][j] = 0;
        for(int i = 1;i<m+1;i++){
            for(int j = 1;j<n+1;j++){
                if(s[i-1] == t[j-1]){
                    dp[i][j] = dp[i-1][j-1] +dp[i-1][j];//分两种情况，第一种是s[i-1]参与匹配，第二种是不参与匹配
                }else{
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        return dp[m][n];
    }
};

5.583两个字符串的删除操作

本题有两种动态规划的方法：

1.按照最长公共子序列的方法求解出最长的公共子序列长度，再用两者的总长度减去两倍的公共长度得到的就是需要操作的步骤。

2.按照不同子序列的思路进行改写。

1.问题描述

找到其中需要进行操作的最少次数。

2.问题转换

添加操作可以将其看做是一个另类的删除操作，所以最后全部都可以看做是一个删除操作

3.解题思路

  1. 每一个位置的word1[i]和word2[j]都有两种状态：是否相等
  2. 如果相等：那么不进行任何操作
  3. 如果不相等：那么此时有两种情况：1.删除word1[i](也可以是添加word1[i]到word2[j]的位置)。2.删除word2[j]（也可以看做是添加word2[j]到word1[i]的位置）确定其最小值就是最少操作次数。

4.为什么使用动态规划？

因为每一个位置的状态都能由前面的状态递推出来

5.动态规划的具体实现

  1. dp[i][j]数组的含义：代表的是从word1[0..i]word2[0..j]最少需要操作的次数保证能够完全匹配。
  2. 递推公式： 
    if(word1[i-1] == word2[j-1]){
                    dp[i][j] = dp[i-1][j-1];
                }else{
                    dp[i][j] = min(dp[i][j-1]+1,dp[i-1][j]+1);
                }
  3. 初始化：for(int i = 0;i<m+1;i++)dp[i][0] = i;for(int j = 1;j<n+1;j++)dp[0][j] = j;因为对于一个是空的字符串，另外一个非空，需要将其全部删除，所以需要进行如下的初始化
  4. 遍历顺序：由递推公式可以知道，应该是从上到下，从左到右的遍历顺序。
class Solution {
public:
    int minDistance(string word1, string word2) {
        //两种思路：第一种是先找到最长的相等的字符串，然后相减即可
        /*
        int m = word1.size();
        int n = word2.size();
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));
        for(int i = 1;i<m+1;i++){
            for(int j = 1;j<n+1;j++){
                if(word1[i-1] == word2[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 m+n-2*dp[m][n];//因为重复的最长字符串，此时需要两倍减去=(m-dp[m][n]+n-dp[m][n]);
        */
        //第二种方法：直接找到对应的需要删除的最小步数
        int m = word1.size();
        int n = word2.size();
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));
        for(int i = 0;i<m+1;i++)dp[i][0] = i;
        for(int j = 1;j<n+1;j++)dp[0][j] = j;
        for(int i = 1;i<m+1;i++){
            for(int j = 1;j<n+1;j++){
                if(word1[i-1] == word2[j-1]){
                    dp[i][j] = dp[i-1][j-1];
                }else{
                    dp[i][j] = min(dp[i][j-1]+1,dp[i-1][j]+1);
                }
            }
        }
        return dp[m][n];
    }
};

mooc666quq
关注
  • 18
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值