算法学习——动态规划之子序列问题

已于 2024-07-17 17:39:27 修改
阅读量382 收藏 7
点赞数 4
文章标签： 学习 动态规划 算法
于 2024-07-15 22:09:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lei453913232/article/details/140365439
版权

目录

一、最长递增子序列

1、O(n^2)做法

二、最长连续递增子序列

三、最长重复子数组

1、方法一

2、方法二

3、滚动数组优化

四、最长公共子序列

五、最大子数组和

六、不同的子序列

七、两个字符串的删除操作

八、编辑距离

九、回文子串

十、最长回文子序列

一、最长递增子序列

        原题力扣300        . - 力扣（LeetCode）

        定义 dp[i] 为以第 i 个元素为结尾的最长递增子序列长度

1、O(n^2)做法

int longestIncreasingSubsequence(vector<int>& nums)
{
	int n = nums.size();
	vector<int> dp(n, 1);
	for (int i = 1; i < n; i++)
	{
		for (int j = 0; j < i; j++)
		{
			if (nums[i] > nums[j])
			{
				dp[i] = max(dp[i], dp[j] + 1);
			}
		}
	}
	return *max_element(dp.begin(), dp.end());
}

二、最长连续递增子序列

        原题力扣674        . - 力扣（LeetCode）

        定义 dp[i] 为以第 i 个元素为结尾的最长连续递增子序列长度

int findLengthOfLCIS(vector<int>& nums)
{
	int n = nums.size();
	vector<int> dp(n, 1);
	for (int i = 1; i < n; i++)
	{
		if (nums[i] > nums[i - 1])
		{
			dp[i] = dp[i - 1] + 1;
		}
	}
	return *max_element(dp.begin(), dp.end());
}

三、最长重复子数组

        原题力扣718        . - 力扣（LeetCode）

1、方法一

         定义 dp[i][j] ：分别以 i-1，j-1 为结尾的nums1，nums2最长重复子数组的长度

int findLength(vector<int>& nums1, vector<int>& nums2)
{
	vector<vector<int>> dp(nums1.size() + 1, vector<int>(nums2.size() + 1));
	for (int i = 0; i <= nums1.size(); i++)
	{
		dp[i][0] = 0;
	}
	for (int j = 0; j <= nums2.size(); j++)
	{
		dp[0][j] = 0;
	}
	int ans = 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;
			}
			ans = max(ans, dp[i][j]);
		}
	}
	return ans;
}

2、方法二

        定义 dp[i][j] ：分别以 i，j 为结尾的nums1，nums2最长重复子数组的长度

int findLength(vector<int>& nums1, vector<int>& nums2)
{
	vector<vector<int>> dp(nums1.size(), vector<int>(nums2.size()));
	for (int i = 0; i < nums1.size(); i++)
	{
		if (nums1[i] == nums2[0])
		{
			dp[i][0] = 1;
		}
	}
	for (int j = 0; j < nums2.size(); j++)
	{
		if (nums1[0] == nums2[j])
		{
			dp[0][j] = 1;
		}
	}
	int ans = 0;
	for (int i = 0; i < nums1.size(); i++)
	{
		for (int j = 0; j < nums2.size(); j++)
		{
			if (i > 0 && j > 0 && nums1[i] == nums2[j])
			{
				dp[i][j] = dp[i - 1][j - 1] + 1;
			}
			ans = max(ans, dp[i][j]);
		}
	}
	return ans;
}

3、滚动数组优化

int findLength(vector<int>& nums1, vector<int>& nums2)
{
	vector<int> dp(nums2.size() + 1, 0);
	int ans = 0;
	for (int i = 1; i <= nums1.size(); i++)
	{
		for (int j = nums2.size(); j > 0; j--)
		{
			if (nums1[i - 1] == nums2[j - 1])
			{
				dp[j] = dp[j - 1] + 1;
			}
			else
			{
				dp[j] = 0; // 注意这里不相等的时候要有赋0的操作
			}
			ans = max(ans, dp[j]);
		}
	}
	return ans;
}

四、最长公共子序列

        原题力扣1143        . - 力扣（LeetCode）

        定义 dp[i][j] ：分别以 i-1，j-1 为结尾的 text1，text2 字符串的最长公共子序列长度

        注意与上题比较

        变形：力扣1035        . - 力扣（LeetCode）        代码一模一样

int longestCommonSubsequence(string text1, string text2)
{
	vector<vector<int>> dp(text1.size() + 1, vector<int>(text2.size() + 1));
	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()];
}

        变形：力扣392        . - 力扣（LeetCode）

bool isSubsequence(string s, string t)
{
	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;
			}
			else
			{
				dp[i][j] = dp[i][j - 1];  // 只能从 t 中删除元素
			}
		}
	}
	return dp[s.size()][t.size()] == s.size();
}

五、最大子数组和

        原题力扣53        . - 力扣（LeetCode）

        定义 dp[i]：以 nums[i] 为结尾的最大子数组和

int maxSubArray(vector<int>& nums)
{
	int n = nums.size();
	vector<int> dp(n, 0);
	dp[0] = nums[0];
	for (int i = 1; i < n; i++)
	{
		dp[i] = max(dp[i - 1] + nums[i], nums[i]);
	}
	return *max_element(dp.begin(), dp.end());
}

六、不同的子序列

        原题力扣115        . - 力扣（LeetCode）

        定义 dp[i][j]：以 i-1 为结尾的 s 中含有以 j-1 为结尾的 t 的个数

int numDistinct(string s, string t)
{
	vector<vector<int>> dp(s.size() + 1, vector<int>(t.size() + 1, 0));
	// 注意初始化，s 中删除任意元素后变成空串的个数只有 1 个
    for (int i = 0; i <= s.size(); i++)
	{
		dp[i][0] = 1;
	}
	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] + dp[i - 1][j];
			}
			else
			{
				dp[i][j] = dp[i - 1][j];
			}
		}
	}
	return dp[s.size()][t.size()];
}

七、两个字符串的删除操作

        原题力扣583        . - 力扣（LeetCode）

        定义 dp[i][j]：以 i-1 为结尾的 word1，以 j-1 为结尾的 word2 的字符串，删除字符使它们相同的最小操作次数

int minDistance(string word1, string word2)
{
	vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
	for (int i = 0; i <= word1.size(); i++)
	{
		dp[i][0] = i;
	}
	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
			{
                // 三种情况：删除word1[i-1]、删除word2[j-1]、同时删除word1和word2
				dp[i][j] = min(dp[i - 1][j] + 1, min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 2));
			}
		}
	}
	return dp[word1.size()][word2.size()];
}

八、编辑距离

        原题力扣72        . - 力扣（LeetCode）

int minDistance(string word1, string word2)
{
	vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
	for (int i = 0; i <= word1.size(); i++)
	{
		dp[i][0] = i;
	}
	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
			{
                // 增删操作相同、替换dp[i - 1][j - 1] + 1
				dp[i][j] = min(dp[i - 1][j] + 1, min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1));
			}
		}
	}
	return dp[word1.size()][word2.size()];
}

九、回文子串

        原题力扣647        . - 力扣（LeetCode）

        定义 dp[i][j]：[i...j]的子串中回文串的数量

int countSubstrings(string s)
{
	vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
	int ans = 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)
				{
					dp[i][j] = true;
					ans++;
				}
				else if (dp[i + 1][j - 1] == true)
				{
					dp[i][j] = true;
					ans++;
				}
			}
		}
	}
	return ans;
}

十、最长回文子序列

        原题力扣516        . - 力扣（LeetCode）

        定义 dp[i][j]：[i...j]范围的子串的最长回文子序列的长度

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

lei453913232
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法设计-动态规划——最长公共子序列
weixin_44034024的博客
12-15 2620
算法介绍 动态规划： 回溯法又称试探法。回溯法的基本做法是深度优先搜索，是一种组织得井井有条的、能避免不必要重复搜索的穷举式搜索算法。 回溯算法的基本思想：从一条路往前走，能进则进，不能进则退回来，换一条路再试。 问题实例 问题描述： 题目： 用回溯法编写一个递归程序解决如下装载问题：有 n 个集装箱要装上 2 艘载重分别为 c1 和 c2的轮船，其中集装箱 i 的重量为 wi（1≤ i ≤ n），且∑ ???????? ≤ ????1 + ????2 ???? ????=1 。问是否有一个合理 的装载方案
Java学习之动态规划-背包问题代码
05-16
动态规划不仅可以解决背包问题，还能应用于其他领域，如最长公共子序列、最短路径问题等。通过熟练掌握动态规划，程序员能够解决各种复杂的计算问题，提高代码效率。 在所提供的压缩包文件中，"动态规划-背包问题...
算法复习——动态规划篇之最长公共子序列问题
NickHan_cs的博客
01-25 1120
算法复习——动态规划篇之最长公共子序列问题 以下内容主要参考中国大学MOOC《算法设计与分析》，墙裂推荐希望入门算法的童鞋学习！ 1. 问题背景 子序列：将给定序列中零个或多个元素（如字符）去掉后所得结果 公共子序列： 给定两个序列XXX和YYY 公共子序列示例 ​ 问题是如何求两个给定序列的最长公共子序列？ 2. 问题定义 最长公共子序列问题（Longest Common Subsequence Problem） 输入： 序列X=<x1,x2,…,xn>X=<x_
(Java) 算法——动态规划 最长公共子序列 图解
lion_no_back的博客
10-21 2322
(Java) 算法——动态规划 最长公共子序列 图解
算法沉淀——动态规划之子序列问题（上）（leetcode真题剖析）
立志做一个高产且细节博主
02-27 1496
这样的动态规划算法通过遍历数组，不断更新状态，最终得到以每个位置为结尾的子序列中最长递增子序列的长度。这样的动态规划算法通过遍历数组，不断更新状态，最终得到以每个位置为结尾的子序列中最长的摆动序列长度。是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。给定一个未排序的整数数组 nums ， 返回最长递增子序列的个数。个位置元素为结尾的所有「子序列」中，最长递增子序列的长度。
数据结构算法设计——动态规划——最长不下降子序列LIS
给你糖ya的博客
12-11 1208
数据结构算法设计——动态规划——最长不下降子序列LIS
算法学习资料——算法.zip
07-24
- 动态规划：用于解决具有重叠子问题和最优子结构的问题，如背包问题、最长公共子序列等。 - 回溯与分支限界：用于在庞大的搜索空间中寻找解决方案，如八皇后问题、N皇后问题等。 3. **算法实现与应用**： - ...
javascript-leetcode面试题解动态规划问题之第300题最长上升子序列-题解.zip
03-16
本题解聚焦于LeetCode的第300题——最长上升子序列（Longest Increasing Subsequence, LIS），这是一个典型的动态规划问题。 动态规划是算法设计的一种策略，通过将复杂问题分解成更小的子问题来解决。在最长上升子...
经典算法——动态规划教程
01-30
- 背包问题：一种典型的动态规划问题，涉及到在容量限制下选择物品以最大化价值。 - 状态转移矩阵：用于表示状态之间转移概率的矩阵，常用于马尔科夫决策过程。 动态规划的思维方法有两种主要类型：正向思维法和...
浙江工业大学算法实验2 动态规划算法实现.pdf
06-05
在浙江工业大学的这个算法实验中，学生们通过两个具体问题——最长公共子序列问题和最大子段和问题——来学习和实践动态规划。 1. 最长公共子序列问题 最长公共子序列（Longest Common Subsequence, LCS）是寻找两...
AvaloniaUI的学习
最新发布
lishuangquan1987的博客
07-25 623
官方中文文档：https://docs.avaloniaui.net/zh-Hans/docs/welcome。
编程学习之路：从零到一的成长指南
KsuferNotes
07-22 466
在当今数字化时代，编程技能已经成为许多人职业发展的重要组成部分。不论你是已经在IT业从业多年的老手，还是刚刚起步的编程新手，这篇博客将带你走过编程学习的每一个重要阶段，从而顺利完成从零到一的华丽转变。
FastAPI（七十一）实战开发《在线课程学习系统》接口开发-- 查看留言
mr~li的博客
07-24 266
梳理后发现，之前在接口设计的时候，有些欠缺，查看留言，是查看单个的留言，查看留言后，对应的留言变成已读状态。那么我们这个都需要传递一个参数，这个参数应该是留言的id。之前FastAPI（七十）实战开发《在线课程学习系统》接口开发--留言功能开发分享了留言开发，这次我们分享查看留言。在之前设计返回状态码的时候，发现状态码有缺失，我们增加下缺失的。3.判断是否是当前用户的留言，或者接受的方是自己。梳理这里的逻辑，这个接口要依赖登录。5.如果已读且回复了，要带回复的内容。以上则是实现查看留言的接口逻辑。
学习华为IPD流程黑话2.0
产品线负责人
07-23 536
管道管理是指根据资源需求（管道需求）尽早地对可获得性资源（管道供给）进行平衡，任何企业做研发、做产品，它的可用资源都是有限的，可以把企业的资源比喻成管道。既是对产品包进行验证，也是内部技能传递的重要环节，同时能为客户带来价值。这个时候就只需要对切片的概念做一下了解就应该可以直接应用了。而且主要做的是 C 语言，Python 也确实没具体用过。并保证在任意时刻产出的研发价值（即出口流量）的最大化，好了，这个话题就不展开来讲了，后续可以单独展开聊聊。评审的对象是新产品的业务计划，而不是产品的开发计划。
DP学习——外观模式
huibin.yun的博客
07-24 272
学而时习之，温故而知新。
后端开发工程师vue2初识的学习
音符犹如代码的博客
07-24 1023
快速认识vue
昇思25天学习打卡营第22天 | DCGAN生成漫画头像
qq_31254435的博客
07-23 908
这一节介绍了深度卷积生成对抗网络DCGAN，相对于经典的GAN网络来说，将生成器中的全连接层换成了反卷积层，而将判别器中的全连接层换成了卷积层，其训练过程和GAN网络基本一样。通过在70171张动漫头像上进行训练，使得该对抗网络能够生成动漫头像图片。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 802
java、数据类型、循环、选择等
sklearn基础学习
招风的黑耳CSDN
07-23 736
sklearn，或者更正式地称为scikit-learn，是一个基于Python的开源机器学习库。它建立在NumPy、SciPy和matplotlib之上，提供了简单而有效的工具用于数据挖掘和数据分析。sklearn支持监督学习和无监督学习算法，包括分类、回归、聚类和降维等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值