动态规划之子序列问题

于 2024-01-23 15:31:34 发布
阅读量959 收藏 18
点赞数 15
文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rain_lin2000/article/details/135759992
版权

动态规划求解子序列问题

首先在开始本篇文章之前，我们必须要弄明白子序列，子序列不同于子数组和子串，子序列不要求是连续的，比如有数组vec = [1,3,5,4,8]，其中v1 = [1,4,8]就是vec的一个子序列，但是v1不是vec的子数组。常见的子数组、子串是有连续这个条件要求的，所有我们解题的时候一定要好好看清楚题目描述（是子序列还是子串）

下面题目的分类列表来自于代码随想录，题解也参照了代码随想录中的讲解(本文为博主的学习笔记，所以有部分是直接在代码随想录中截图的，大家多多支持开源作者，可以前往学习）

https://www.programmercarl.com/

1.子序列（不连续）

1.1最长上升子序列

在这里插入图片描述

dp数组的定义以及状态转移方程

在这里插入图片描述

解法一：动态规划

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        if(nums.size() <= 1) return nums.size();
        //dp[i]表示以nums[i]结尾的最长递增子序列的长度
        vector<int> dp(nums.size(), 1);
        int result = 1;
        for(int i = 1; i < nums.size(); i++){
            for(int j = 0; j < i; j++){
                if(nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);
            }
            if(dp[i] > result) result = dp[i];
        }
        return result;
    }
};

解法二：递归 + 记忆化搜索

class Solution {
public:
    int lengthOfLIS(vector<int> &nums) {
        int n = nums.size(), memo[n];
        memset(memo, 0, sizeof(memo)); // 本题可以初始化成 0，表示没有计算过
        function<int(int)> dfs = [&](int i) -> int {
            int &res = memo[i];
            if (res) return res;
            for (int j = 0; j < i; ++j)
                if (nums[j] < nums[i])
                    res = max(res, dfs(j));
            return ++res;
        };
        int ans = 0;
        for (int i = 0; i < n; ++i)
            ans = max(ans, dfs(i));
        return ans;
    }
};

1.2最长公共子序列

在这里插入图片描述

dp数组含义的确立以及状态转移方程

在这里插入图片描述

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        //dp[i][j]表示以text1[i]&&text2[i]结尾序列的最长长度
        vector<vector<int>> dp(text1.size() + 1, vector<int>(text2.size() + 1, 0));
        for(int i = 1; i <= text1.size(); i++){
            for(int j = 1; j <= text2.size(); 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[text1.size()][text2.size()];
    }
};

1.3不相交的线

在这里插入图片描述一定要擅于分析题目，将一些题目信息充分利用，转化为我们熟悉的题目，比如这个题目：绘制一些连接两个数字 A[i] 和 B[j] 的直线，只要 A[i] == B[j]，且直线不能相交！直线不能相交，这就是说明在字符串A中 找到一个与字符串B相同的子序列，且这个子序列不能改变相对顺序，只要相对顺序不改变，链接相同数字的直线就不会相交。本题说是求绘制的最大连线数，其实就是求两个字符串的最长公共子序列的长度！，和上面的题目本质是一模一样的。

class Solution {
public:
    //剖析这个题目，其本质为找到最长公共子序列
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        //dp[i][j]的含义表示为：以nums1以下标i - 1结尾，nums2以下标j - 1结尾时的最长子序列长度
        //但是我们不要被误导了：nums1[i - 1]与nums2[j - 1]不一定相等！
        vector<vector<int>> dp(nums1.size() + 1, vector<int>(nums2.size() + 1, 0));
        for(int i = 1; i <= nums1.size(); i++){
            for(int j = 1; j <= nums2.size(); j++){
                if(nums1[i - 1] == nums2[j - 1]){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }else{
                    dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
                }
            }
        }
        return dp[nums1.size()][nums2.size()];
    }
};

2.子序列（连续）

2.1最长连续递增子序列

在这里插入图片描述这个题目和题1.1的区别在于此出连续，也就是选择最长递增子数组的长度，好好对比两个题目的题解区别

dp数组的定义以及状态转移

在这里插入图片描述

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        if(nums.size() <= 1) return nums.size();
        vector<int> dp(nums.size(), 1);
        int result = 0;
        for(int i = 1; i < nums.size(); i++){
            if(nums[i] > nums[i - 1]){
                dp[i] =dp[i - 1] + 1;
            }
            result = max(result, dp[i]);
        }
        return result;
    }
};

2.2最长重复子数组

在这里插入图片描述

dp数组的定义以及状态转移方程

在这里插入图片描述

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        //dp[i][j]:表示以nums1[i-1]结尾&&以nums2[j-1]结尾的最长重复子数组长度
        vector<vector<int>> dp(nums1.size() + 1, vector<int>(nums2.size() + 1, 0));
        int result = 0;
        for(int i = 1; i <= nums1.size(); i++){
            for(int j = 1; j <= nums2.size(); j++){
                if(nums1[i - 1] == nums2[j - 1]){
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                if(dp[i][j] > result) result = dp[i][j];
            }
        }
        return result;
    }
};

2.3最大子序和

在这里插入图片描述

dp数组的定义以及状态转移方程

在这里插入图片描述

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size() <= 1) return nums[0];
        //dp[i]表示以nums[i]结尾的连续子数组的最大值
        vector<int> dp(nums.size(), 0);
        dp[0] = nums[0];
        int result = dp[0];
        for(int i = 1; i < nums.size(); i++){
            if(nums[i] > 0) dp[i] = max(dp[i - 1] +nums[i], nums[i]);
            else dp[i] = max(nums[i],nums[i] + dp[i - 1]);
            result = max(result, dp[i]);
        }
        return result;
    }
};

3.编辑距离

3.1判断子序列

在这里插入图片描述

解法一：双指针解法（普通直接想到的解法）

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n = s.length(), m = t.length();
        int i = 0, j = 0;
        while (i < n && j < m) {
            if (s[i] == t[j]) {
                i++;
            }
            j++;
        }
        return i == n;
    }
};

动态规划

在这里插入图片描述

class Solution {
public:
    //这个题目可以用最长公共子序列来做（最长的长度==s.size()则为true,否则为false）
    bool isSubsequence(string s, string t) {
        //dp[i][j]表示s截止s[i - 1](含s[i - 1])和t截止t[j - 1]的子串的最长子序列长度
        vector<vector<int>> dp(s.size() + 1, vector<int>(t.size() + 1, 0));
        for(int i = 1; i <= s.size(); i++){
            for(int j = 1; j <= t.size(); j++){
                if(s[i - 1] == t[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
                //由于s是最简待匹配串，所以原本最长子序列中的代码（dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])）可以换成下面的;
                else dp[i][j] = dp[i][j - 1];
            }
        }
        return dp[s.size()][t.size()] == s.size();
    }
};

3.2不同的子序列

在这里插入图片描述

dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。

状态转移方程

在这里插入图片描述

class Solution {
public:
    //统计s的所有子序列中有多少个和t相同
    int numDistinct(string s, string t) {
        //dp[i][j]:以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]
        vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1));
        //dp[i][0]表示以i - 1结尾的s得到空字符串这个子序列的个数（一定是1，为空全部清除就行）
        for(int i = 0; i < s.size(); i++) dp[i][0] = 1;
        //dp[0][j]无论如何都为0，空字符串无法有任何子序列（除开空字符串之外，所以dp[0][0]=0)
        for(int j = 1; j < t.size(); j++) dp[0][j] = 0;
        //开始动态规划的过程
        for(int i = 1; i <= s.size(); i++){
            for(int j = 1; j <= t.size(); j++){
                if(s[i - 1] == t[j - 1]){
                    //s:bagg t:bag 我们可以选择第一个g或者第二个取匹配，所以这里等于两者方法数量的和
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                }else{
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[s.size()][t.size()];
    }
};

3.3两个字符串的删除操作

在这里插入图片描述

状态转移方程的确定

在这里插入图片描述

class Solution {
public:
    //求两个字符串的公共最长子序列
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size() + 1, vector(word2.size() + 1, 0));
        for(int i = 1; i <= word1.size(); i++){
            for(int j = 1; j <= word2.size(); 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 word1.size() + word2.size() - 2 * dp[word1.size()][word2.size()];
    }
};

3.4编辑距离

在这里插入图片描述

dp[i][j]:下标为0~i-1的word1子字符串,和以下标j-1为结尾的字符串word2的最近编辑距离

class Solution {
public:
    //dp[i][j]:下标为0~i-1的word1子字符串,和以下标j-1为结尾的字符串word2的最近编辑距离
    //状态转移方程：word1[i - 1] = word2[j - 1]，不用操作；不相等时需要进行增、删、换中的某一种操作
    //其中删除操作与增加操作等价。比如word1=ad, word2 =d， word1删除a或者word2添加a的操作次数的相等的
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
        //初始化：dp[i][0] word1[0:i）需要操作i次才能边为空（此时的word2[0:0)是空的
        for(int i = 0; i <= word1.size(); i++) dp[i][0] = i;
        //dp[0][j]初始化理由同上，需要操作j次才能为空
        for(int j = 0; j <= word2.size(); j++) dp[0][j] = j;
        //开始动态规划
        for(int i = 1; i <= word1.size(); i++){
            for(int j = 1; j <= word2.size(); j++){
                if(word1[i - 1] == word2[j - 1]){
                    dp[i][j] = dp[i - 1][j - 1];
                }else{//不相等的时候需要操作
                    //删除操作：min(word1删除一个元素，word2删除一个元素) + 1 = min(dp[i][j - 1],dp[i - 1][j])+1
                    //替换操作：dp[i - 1][j - 1] + 1（上一个最近距离加上一次替换操作）
                    dp[i][j] = min(min(dp[i][j - 1],dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
                }
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

4.回文

4.1回文子串

在这里插入图片描述下面注释中的写法实现的过程是相同的，只是将逻辑进行了提取的

class Solution {
public:
    int countSubstrings(string s) {
        //isPalindrome[i][j] == true表示s[i:j]为回文串（闭区间）
        vector<vector<bool>> isPalindrome(s.size(), vector<bool> (s.size(), false));
        int count = 0;
        for(int i = s.size() - 1; i >= 0; i--){
            for(int j = i; j < s.size();j++){
                if(j == i){
                    isPalindrome[i][j] = true;
                }else if(j - i == 1){
                    isPalindrome[i][j] = (s[i] == s[j]);
                }else{
                    isPalindrome[i][j] = (s[i] == s[j] && isPalindrome[i + 1][j - 1]);
                }
                //如果是回文的话，那么增加数量
                if(isPalindrome[i][j]) count++;
            }
        }
        return count;

        // //dp[i][j] 表示s[i:j](左闭右闭)区间是否为回文串
        // vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
        // int result = 0;
        // for(int i = s.size() - 1; i　>= 0; i--){
        //     for(int j = i; j < s.size();j++){
        //         if(s[i] == s[j]){
        //             if(j - i <= 1){
        //                 result++;
        //                 dp[i][j] = true;
        //             }else if(dp[i + 1][j - 1]){
        //                 result++;
        //                 dp[i][j] = true;
        //             }
        //         }
        //     }
        // }
        // return result;
    }
};

4.2最长回文子序列

在这里插入图片描述
一定要注意，这里是回文子序列，不是回文子串！！！子串是子序列，但是子序列并不一定是子串

dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。

状态转移方程的确立

在这里插入图片描述核心代码如下

if (s[i] == s[j]) {
    dp[i][j] = dp[i + 1][j - 1] + 2;
} else {
    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
}

完整实现代码

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
        for(int i = 0; i < s.size(); i++) dp[i][i] = 1;//单个字母为回文，且长度为1
        for(int i = s.size() - 1; i >= 0; i--){
            for(int j = i + 1; j < s.size(); j++){
                if(s[i] == s[j]){
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                }else{
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[0][s.size() - 1];

    }
};
佳雨初林
关注
  • 15
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
动态规划求解子序列问题
CTGUACM
12-20 623
文章目录一、1. 最长递增子序列（即经典的LIS）二、使用步骤1.引入库2.读入数据总结 一、 1. 最长递增子序列（即经典的LIS） HDU 1257 题目实意：给定长度为 n 的元素不重复的数组 a，求其最长递增子序列的长度 分析：首先我们将每一个字符都看成一个子序列，长度是1，接着暴力枚举，我们需要从头到尾依次枚举是否选择当前的数字，选择一个数后就要看看与前面的数是否满足连续上升，符合条件后再判断比较哪一个更长，这就是一个不断向下求解子问题的过程，且中间存在重复子问题，从下至上将子结构的最优解..
动态规划—最长子序列问题
zhojhon的博客
05-10 1085
1.   问题引出 最长字段匹配问题归结如下： 假设存在两个字符段： A={'a', 'b', 'c','b', 'd', 'a', 'b'}; B= {'b', 'd','c', 'a', 'b', 'a'}; 则A、B两个字段的匹配即为A、B的公共子序列，如{‘a’}、{‘b’}、{‘b、‘d’}、{‘b’、’c’、’a’、’b’}均为该两个字符段的公共子序列，而最长公共子序列则为以
剑指offer-例题 栈的压入、弹出序列
qq_39622795的博客
09-28 547
题目描述 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的） import java.util.ArrayList; import java.util.Stack; public class Solution { public boolean I
动态规划---最长连续子序列问题
m0_51431003的博客
10-01 3626
动态规划---连续子数列问题
最长公共子序列和最长公共子串的动态规划实现(java)
晓茸有点甜的博客
03-27 5733
最长公共子序列和最长公共子串的动态规划算法实现，java代码以及个人见解。
利用动态规划解决最长增长子序列问题
qq_44753451的博客
10-18 3183
利用动态规划解决最长增长子序列问题题目及概念题目描述子序列增长（或上升）子序列最长增长子序列分析并解决题目寻求解决问题的方法构建动态规划的模型分析优化解的结构构造状态转换方程优化解的构建过程存储结构的优化优化存储结构思路举例markmarkmark 题目及概念 题目描述 子序列   先引入一段来自百度百科的介绍：子序列简称子列.指序列的一部分项按原有次序排列而得的序列.设｛an｝∞n=1是序列，k1<k2<…<kn<…是一列正整数，则称序列｛akn｝∞n=1为｛an｝∞n=1的子序
动态规划——最长公共子序列
热门推荐
Wu_L7的博客
04-19 1万+
动态规划之最长公共子序列（PTA）
动态规划问题-最长单调递增子序列问题
11-08
L={a1,a2,a3,…,an}，是由n个不同的实数组成的序列，求L的最长单调递增子序列的长度（下标可不连续）
动态规划求解最长公共子序列问题
10-14
在本主题中，我们将深入探讨如何利用动态规划来求解“最长公共子序列”（Longest Common Subsequence，简称LCS）问题。 最长公共子序列问题是指给定两个或多个字符串，找到它们之间最长的子序列，这个子序列不必是...
基于Java+动态规划算法解决最长公共子序列问题.zip
最新发布
05-10
动态规划是解决LCS问题的主要算法之一，它通过构建一个二维数组来存储子问题的解，避免了重复计算，提高了效率。 动态规划解法的基本思路如下： 1. 定义二维数组`dp[i][j]`，表示字符串1的前i个字符和字符串2的前j...
最长公共子序列，C语言动态规划
01-17
可以根据里面代码修改具体输出，实现过程根据《算法导论》
最长公共子序列的动态规划算法
03-25
利用动态规划法求出两个序列的最长公共子序列，内含C++源代码和实验报告
最长公共子序列问题 动态规划法.cpp.rar
10-14
在本例中，提供的文件是使用C++语言实现的动态规划解法，名为“最长公共子序列问题 动态规划法.cpp”。 动态规划是一种解决问题的有效方法，它通过将复杂问题分解为一系列更小的子问题来求解。在解决LCS问题时，...
动态规划求解最长公共子序列
12-29
动态规划求解并输出所有LCS
最长重复子数组&&最长公共子序列&&不相交的线
YXXXYX的博客
08-03 382
引言 这同样是两种类型的题目，有很多相似的地方和不同的地方，区别依然是连续和不连续之分。 最长重复子数组 给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。 示例： 输入： A: [1,2,3,2,1] B: [3,2,1,4,7] 输出：3 解释： 长度最长的公共子数组是 [3, 2, 1] 。 提示： 1 <= len(A), len(B) <= 1000 0 <= A[i], B[i] < 100 这道题中说的子数组，其实就是连续的子序列， 1，d
动态规划之经典中的经典——公共最长子序列
xyk：的博客
03-30 1645
第二步：找出数组元素之间的关系式，当我们要计算dp[n]时，是可以利用dp[n-1],dp[n-2]....dp[1],来推出dp[n]，也就是可以利用子结果去推出新的元素值，重点就是找到数组元素之间的关系，例如dp[n] = dp[n-1]+dp[n-2]，这个就是他们的关系。当 n = 2 时，dp[2] = dp[1] + dp[0] = 1。第三步：找出初始值，也就是最开始的值，例如dp[1],dp[2].....，有了初始值，根据关系式就可以推出dp[n]，而 dp[n] 的含义是由你来定义的。
最长公共子序列问题（动态规划）
m0_52124992的博客
03-28 7346
最长公共子序列问题 动态规划
动态规划篇——最长公共子序列(c++)
qq_43353709的博客
06-11 1万+
引言：最长公共子序列属于动态规划的基础篇，由字符串的最长公共最序列可以引出很多的问题。 最长子序列详细讲解以及练习题目 需要详细讲解教程的可以观看上面链接的文章，以下是自己做的简单的概括。 一、何为最长公共子序列 A和B的公共子序列中长度最长的（包含元素最多的）叫做A和B的公共子序列。 仍然用序列1,3,5,4,2,6,8,7和序列1,4,8,6,7,5 它们的最长公共子序列是： 1,4,8,7...
动态规划算法（2）--最大子段和与最长公共子序列
人工智能小白
10-02 2794
最大子段和的暴力枚举、分治法、动态规划法的思路，最长公共子序列暴力检索、动态规划法的思路。
动态规划解决最长递增子序列问题详解
本文主要探讨的是二最长递增子序列（Longest Increasing Subsequence, LIS）问题，这是一个经典的动态规划(DP)问题，尤其与最长公共子序列（Longest Common Subsequence, LCS）相对应。LIS的问题设定是给定一个由n个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值