C++中的动态规划子序列问题分析探讨
更新时间：2023年03月15日 08:55:05 作者：清风何渡
可能有些读者有接触过动态规划，可能也有一些读者以前完全不知道动态规划这个东西，别担心，我这篇文章会为读者做一个入门，好让读者掌握这个重要的知识点
一、子序列(不连续)
最长上升子序列
经典问题
int lengthOfLIS(int* nums, int numsSize){
//1.dp[i]表示遍历到nums[i]时，最长递增子序列的长度
//2.递推式:
//if(nums[j]<nums[i]) dp[i]=fmax(dp[i],dp[j]+1);
//3.dp数组初始化:
//dp[i]=1;
int dp[numsSize];
for(int i=0;i<numsSize;i++)
dp[i]=1;
int ans=1;
for(int i=1;i<numsSize;i++){
for(int j=0;j<i;j++){
if(nums[j]<nums[i])
dp[i]=fmax(dp[i],dp[j]+1);
ans=fmax(ans,dp[i]);
}
}
return ans;
}最长公共子序列
经典问题
int longestCommonSubsequence(char * text1, char * text2){
//1.dp[i][j]表示text1[0...i]与text2[0...j]的最长公共子序列的长度
//2.递推式:
//if(text1[i]==text2[j]) dp[i][j]=dp[i-1][j-1]+1;
//else dp[i][j]=fmax(dp[i-1][j],dp[i][j-1]);
//3.dp数组初始化:
//dp[i][0]=dp[0][j]=0;
int len1=strlen(text1);
int len2=strlen(text2);
int dp[len1+1][len2+1];
for(int i=0;i<=len1;i++) dp[i][0]=0;
for(int j=0;j<=len2;j++) dp[0][j]=0;
for(int i=1;i<=len1;i++){
for(int j=1;j<=len2;j++){
if(text1[i-1]==text2[j-1])
dp[i][j]=dp[i-1][j-1]+1;
else
dp[i][j]=fmax(dp[i-1][j],dp[i][j-1]);
}
}
return dp[len1][len2];
}不相交的线
该问题=求最长公共子序列（数组版本）
int maxUncrossedLines(int* nums1, int nums1Size, int* nums2, int nums2Size){
int dp[nums1Size+1][nums2Size+1];
for(int i=0;i<=nums1Size;i++) dp[i][0]=0;
for(int j=0;j<=nums2Size;j++) dp[0][j]=0;
for(int i=1;i<=nums1Size;i++){
for(int j=1;j<=nums2Size;j++){
if(nums1[i-1]==nums2[j-1])
dp[i][j]=dp[i-1][j-1]+1;
else
dp[i][j]=fmax(dp[i-1][j],dp[i][j-1]);
}
}
return dp[nums1Size][nums2Size];
}二、子序列(连续)
最长连续递增序列
与最长上升子序列相比，多了“连续”这个条件，故只需要比较相邻元素大小即可，不相等dp置为1
int findLengthOfLCIS(int* nums, int numsSize){
//1.dp[i]表示遍历到nums[i]时，最长连续递增子序列的长度
//2.递推式:
//if(nums[i]>nums[i-1]) dp[i]=dp[i-1]+1;
//3.dp数组初始化:
//dp[i]=1;
int dp[numsSize];
for(int i=0;i<numsSize;i++) dp[i]=1;
int ans=1;
for(int i=1;i<numsSize;i++){
if(nums[i]>nums[i-1])
dp[i]=dp[i-1]+1;
ans=fmax(ans,dp[i]);
}
return ans;
}最长重复子数组
与最长公共子序列相比，多了“连续”这个条件，不相等dp置为0
int findLength(int* nums1, int nums1Size, int* nums2, int nums2Size){
int dp[nums1Size+1][nums2Size+1];
for(int i=0;i<=nums1Size;i++) dp[i][0]=0;
for(int j=0;j<=nums2Size;j++) dp[0][j]=0;
int ans=0;
for(int i=1;i<=nums1Size;i++){
for(int j=1;j<=nums2Size;j++){
if(nums1[i-1]==nums2[j-1])
dp[i][j]=dp[i-1][j-1]+1;
else
dp[i][j]=0;
ans=fmax(ans,dp[i][j]);
}
}
return ans;
}最大子序和
很简单，i-1到i时，dp[i]选择dp[i-1]或者不选择
int maxSubArray(int* nums, int numsSize){
//1.dp[i]表示nums[0...i]中最大子数组和
//2.递推式:
//dp[i]=fmax(dp[i-1]+nums[i],nums[i]);
//3.dp数组初始化:
//dp[0]=nums[0];
int dp[numsSize];
dp[0]=nums[0];
int ans=dp[0];
for(int i=1;i<numsSize;i++){
dp[i]=fmax(dp[i-1]+nums[i],nums[i]);
ans=fmax(ans,dp[i]);
}
return ans;
}三、编辑距离
判断子序列
这题虽然用暴力法设置两个指针遍历更简单，但是为了训练编辑距离题型的思想，建议从动态规划入手
bool isSubsequence(char * s, char * t){
//1.dp[i][j]表示遍历到s[i]和t[j]时，两数组的最长公共子序列长度
//2.递推式:
//if(s[i-1]==t[j-1]) dp[i][j]=dp[i-1]+dp[i-1]+1;
//else dp[i][j]=fmax(dp[i-1][j],dp[i][j-1]);
//3.dp数组初始化:
//dp[i][0]=dp[0][j]=0;
int m=strlen(s),n=strlen(t);
int dp[m+1][n+1];
for(int i=0;i<=m;i++) dp[i][0]=0;
for(int j=0;j<=n;j++) dp[0][j]=0;
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
if(s[i-1]==t[j-1])
dp[i][j]=dp[i-1][j-1]+1;
else
dp[i][j]=dp[i][j-1];
}
}
if(dp[m][n]==m) return true;
else return false;
}两个字符串的删除操作
这一题理解起来有点吃力，但是好在后面两题都要用，熟能生巧
int minDistance(char * word1, char * word2){
//1.dp数组的含义:
//dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，
//想要达到相等，所需要删除元素的最少次数
//2.递推式:
//若word1[i-1]==word2[j-1]:
// 无需进行删除操作，即删除次数无变化，dp[i][j]=dp[i-1][j-1];
//若word1[i-1]!=word2[j-1]:
// 若删除word1[i-1]，问题就变成了dp[i-1][j]基础上加了一次删除操作，dp[i][j]=dp[i-1][j]+1;
// 若删除word2[j-1]，问题就变成了dp[i][j-1]基础上加了一次删除操作，dp[i][j]=dp[i][j-1]+1;
// 综上，dp[i][j]=fmin(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
//3.dp数组初始化:
//dp[i][0]=i,dp[0][j]=j;
int m=strlen(word1),n=strlen(word2);
int dp[m+1][n+1];
for(int i=0;i<=m;i++) dp[i][0]=i;
for(int j=1;j<=n;j++) dp[0][j]=j;
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
if(word1[i-1]==word2[j-1])
dp[i][j]=dp[i-1][j-1];
else
dp[i][j]=fmin(dp[i-1][j]+1,dp[i][j-1]+1);
}
}
return dp[m][n];
}不同的子序列
上题是问删除多少次能使得两字符串相等，这题是问有多少种删除组合能使得两字符串相等，而且这一题只有s这一个字符串需要删除
int numDistinct(char * s, char * t){
//这题也可以这样问:s最多有多少种删除方法，可以使得s==t
//1.dp数组的含义:
//dp[i][j]：以i-1为结尾的字符串s，和以j-1位结尾的字符串t，
//想要达到相等，s的最多删除组合
//2.递推式:
//若s[i-1]==t[j-1]:
// s不删，保证s[i-1]和t[j-1]匹配，dp[i][j]=dp[i-1][j-1]];
// s也能删，反正s后面多的是有可能和t[j-1]匹配的选手，dp[i][j]=dp[i-1][j];
//若s[i-1]!=t[j-1]:
// s必须删，否则从s[i-1]和t[j-1]开始s和t就不匹配了，dp[i][j]=dp[i-1][j];
//3.dp数组初始化:
//dp[i][0]=1;dp[0][j]=0;
int m=strlen(s),n=strlen(t);
unsigned long long dp[m+1][n+1];
for(int i=0;i<=m;i++) dp[i][0]=1;
for(int j=1;j<=n;j++) dp[0][j]=0;
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++){
if(s[i-1]==t[j-1])
dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
else
dp[i][j]=dp[i-1][j];
}
}
return dp[m][n];
}编辑距离
BOSS降临，但其实只要掌握了第2题，这一题也就多了个替换操作
int minDistance(char * word1, char * word2){
//这题是编辑距离问题的大BOSS,同时也是最适合背的,见过的秒杀，没见过的干瞪眼
//1.dp[i][j]表示word1的0~i-1部分转换成word2的0~j-1部分所使用的最少操作数
//2.递推式:
//if(word1[i-1]==word2[j-1])-----------等于,无需编辑
// dp[i][j]=dp[i-1][j-1];
//else{
// dp=min(
// dp[i-1][j]+1,------------------删除word1[i-1],就是在word1[0~i-2]与word2[0~j-1]基础上的操作+1
// dp[i][j-1]+1,------------------删除word2[j-1],就是在word2[0~j-2]与word1[0~i-1]基础上的操作+1
// dp[i-1][j-1]+1-----------------只需要一次替换操作，就能使问题变成word1[i-1]==word2[j-1]的情况
// );
//}
//3.dp数组初始化:
//dp[i][0]=i;dp[0][j]=j;
int len1=strlen(word1);
int len2=strlen(word2);
int dp[len1+1][len2+1];
for(int i=0;i<=len1;i++) dp[i][0]=i;
for(int j=1;j<=len2;j++) dp[0][j]=j;
for(int i=1;i<=len1;i++){
for(int j=1;j<=len2;j++){
if(word1[i-1]==word2[j-1])
dp[i][j]=dp[i-1][j-1];
else{
int temp=fmin(dp[i-1][j]+1,dp[i][j-1]+1);
dp[i][j]=fmin(temp,dp[i-1][j-1]+1);
}
}
}
return dp[len1][len2];
}四、回文
回文子串
dp[i][j]的取值依赖于dp[i+1][j-1]的取值（即外层依赖于里层）
因此在遍历顺序上也要保证从左下方到右上方，这样才能保证左下方的数据是经过计算的
int countSubstrings(char * s){
//1.dp[i][j]表示区间范围[i,j]内的字符串是否为回文串
//2.递推式:
//若s[i]!=s[j]:
// 显然,dp[i][j]=false;
//若s[i]==s[j]:
// 若j-i<=1: ans++;dp[i][j]=true;
// 若j-i>1且dp[i+1][j-1]==true:dp[i][j]=true;
//3.dp数组初始化:
//dp[i][j]=false;
//4.dp数组遍历顺序
//dp[i][j]的取值依赖于dp[i+1][j-1]，则应该从下到上、从左到右
int len=strlen(s);
int dp[len][len];
for(int i=0;i<len;i++){
for(int j=0;j<len;j++)
dp[i][j]=false;
}
int ans=0;
for(int i=len-1;i>=0;i--){
for(int j=i;j<len;j++){
if(s[i]==s[j]){
if(j-i<=1){
ans++;
dp[i][j]=true;
}else if(dp[i+1][j-1]){
ans++;
dp[i][j]=true;
}
}
}
}
return ans;
}最长回文子串
还是要注意遍历顺序，dp[i][j] 依赖于 dp[i + 1][j - 1] ，dp[i + 1][j] 和 dp[i][j - 1]，因此，要保证从左下方到右上方遍历，这样才能保证左下方、左方、下方的数据是经过计算的
int longestPalindromeSubseq(char * s){
//1.dp[i][j]表示字符串在[i,j]范围内的最长回文子序列长度
//2.递推式:
//if(s[i]==s[j])
// dp[i][j]=dp[i+1][j-1]+2;
//else
// dp[i][j]=fmax(dp[i+1][j],dp[i][j-1]);
//3.初始化:
//dp[i][i]=1
//4.遍历顺序:
//从下到上、从左到右
int len=strlen(s);
int dp[len][len];
memset(dp,0,sizeof(dp));
for(int i=0;i<len;i++) dp[i][i]=1;
for(int i=len-1;i>=0;i--){
for(int j=i+1;j<len;j++){
if(s[i]==s[j])
dp[i][j]=dp[i+1][j-1]+2;
else
dp[i][j]=fmax(dp[i+1][j],dp[i][j-1]);
}
}
return dp[0][len-1];
}到此这篇关于C++中的动态规划子序列问题分析探讨的文章就介绍到这了,更多相关C++动态规划子序列内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
EasyX是针对C/C++的图形库，可以帮助使用C/C++语言的程序员快速上手图形和游戏编程。本文将为大家详细讲讲EasyX的鼠标操作，需要的可以参考一下2022-07-07
这篇文章主要介绍了C++ STL之slist单向链表容器使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-04-04
通过点击程序界面上不同的布局按钮,使主工作区呈现出不同的页面布局,多个布局之间可以通过点击不同布局按钮切换,支持的最多的窗口为9个,不同布局下窗口数随之变化,这篇文章主要介绍了Qt实现手动切换多种布局的完美方案,需要的朋友可以参考下2024-07-07
这篇文章主要为大家详细介绍了基于QT实现文件上传和下载功能，支持断点续传，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2022-08-08
Qt图形图像开发之高性能曲线图模块QCustomplot库详细使用方法与实例(支持动、静曲线图)
这篇文章主要介绍了Qt图形图像开发之高性能曲线图模块QCustomplot库详细使用方法与实例(支持动、静曲线图),需要的朋友可以参考下2020-03-03
隐式类型转换是安全的,显式类型转换是有风险的,C语言之所以增加强制类型转换的语法,就是为了强调风险,让程序员意识到自己在做什么,本文将给大家详细介绍一下C++中的四种类型转换运算符,需要的朋友可以参考下2023-09-09
这篇文章主要介绍了Qt利用Qchart组件展示数据库中的历史数据。文中的示例代码讲解清晰，具有一定的学习和工作价值，感兴趣的小伙伴可以学习一下2021-12-12
面向对象中对象是指具体的某一个事物，这些事物的抽象就是类，类中包含数据（成员变量）和动作（成员方法），接下来让我们一起详细了解2022-04-04
今天小编就为大家分享一篇opencv3/C++图像滤波实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2019-12-12
这篇文章主要为大家介绍了c++类型转换及RTTI运行阶段类型识别详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步早日升职加薪2023-05-05
最新评论