🍦🍦🍦今天，我们来继续看动态规划剩下的题型：最长公共子序列（LCS）、背包类问题、记忆化搜索、字符串相关的动态规划。继续加油！( •̀ ω •́ )✧
目录
🧊🧊🧊8.4 最长公共子序列（LCS）
定义
最长公共子序列（LCS）是一个在一个序列集合中（通常为两个序列）用来查找所有序列中最长子序列的问题。一个数列 ，如果分别是两个或多个已知数列的子序列，且是所有符合此条件序列中最长的，则称为已知序列的最长公共子序列。
接下来我们分析算法的状态转移方程 ：
（dp[i, j]代表 a 字符串前 i 个字符组成的子串和 b 字符串前 j 个字符组成的子串的 LCS）
那么
dp[i, j] = 0 if i = 0 or j = 0
dp[i, j] = dp[i - 1, j - 1] + 1 if i, j > 0 and ai = bj
dp[i, j] = max{dp[i, j - 1], dp[i - 1, j]} if i, j > 0 and ai != bj
根据上面的状态转移方程可以写出一下代码：
for(int i = 1; i <= lena; ++i) {
for (int j = 1; j <= lenb; ++j) {
if(a[i - 1] == b[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}🥥例题：DreamJudge 1293
最长公共子序列（LCS）模板题。
背过这个模板！！！
#include <bits/stdc++.h>
using namespace std;
int dp[101][101];
int main() {
string a, b;
memset(dp, 0, sizeof(dp));
cin >> a >> b;
int lena = a.size();
int lenb = b.size();
for(int i = 1; i <= lena; ++i) {
for (int j = 1; j <= lenb; ++j) {
if(a[i - 1] == b[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
cout << dp[lena][lenb] << endl;
return 0;
}🥥练习题目：
DreamJudge 1731 最长公共子序列
#include<bits/stdc++.h>
using namespace std;
int main()
{
string a,b;
int dp[1010][1010];
while(cin>>a>>b)
{
int lena=a.size(),lenb=b.size();
memset(dp,0,sizeof(dp));
for(int i=1;i<=lena;i++)
{
for(int j=1;j<=lenb;j++)
{
if(a[i-1]==b[j-1]) dp[i][j]=dp[i-1][j-1]+1;
else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
}
}
cout<<dp[lena][lenb]<<endl;
}
return 0;
}DreamJudge 1737 骑车路线 🍰
//如果a[i]>a[i-1] 保持递增,dp[i]=dp[i-1]+1;
//否则,重新计算爬坡，dp[i]=1;
//当前坡度计算：a[i]- a[i-dp[i]+1]，如果大于ans，更新ans
//摘自N诺用户：xx_about123456
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n=0;
int a[1010];
int dp[1010];
while(cin>>n)
{
for(int i=1;i<=n;i++) cin>>a[i];
int ans=0;
dp[1]=1;
for(int i=1;i<=n;i++)
{
if(a[i]>a[i-1]) dp[i]=dp[i-1]+1;
else dp[i]=1;
if(a[i]-a[i-dp[i]+1]>ans) ans=a[i]-a[i-dp[i]+1];
}
cout<<ans<<endl;
}
return 0;
}DreamJudge 1730 最长连续公共子序列
output limit exceeded原因：直接用模板时，满足代码条件的可以是：a非连续lcs == b非连续lcs ; a非连续lcs == b连续lcs ; a连续lcs == b非连续lcs ; a连续lcs == b连续lcs。而这题只需要第四种的答案，算出来的答案却是这四种的最大值。
需要修改的地方在代码中给出注释了~
#include<bits/stdc++.h>
using namespace std;
int main()
{
string a,b;
int dp[105][105];
while(cin>>a>>b)
{
memset(dp,0,sizeof(dp));
int lena=a.size(),lenb=b.size(),pos,ans=0;
for(int i=1;i<=lena;i++)
{
for(int j=1;j<=lenb;j++)
{
if(a[i-1]==b[j-1])
{
dp[i][j]=dp[i-1][j-1]+1;
}
else dp[i][j]=0;//要求连续，所以这里和模板不一样了
if(dp[i][j]>=ans)//这里也是，ans不再是dp[lena][lenb]了
{
ans=dp[i][j];
pos=i;
}
}
}
cout<<ans<<endl<<a.substr(pos-ans,ans)<<endl;
}
return 0;
}DreamJudge 1664 最大连续子序列
//摘自N诺用户：藕糖
#include<bits/stdc++.h>
using namespace std;
int main() {
int K;
while (cin >> K) {
if (K == 0) break;
vector<int> nums(K);
for (int i = 0; i < K; ++i) {
cin >> nums[i];
}
int maxSum = 0;
int currentSum = 0;
int start = 0, end = 0, tempStart = 0;
bool allNegative = true;
int maxElement = nums[0];
for (int i = 0; i < K; ++i) {
if (nums[i] > maxElement) {
maxElement = nums[i];
}
if (nums[i] >= 0) {
allNegative = false;
}
currentSum += nums[i];
if (currentSum > maxSum) {
maxSum = currentSum;
start = tempStart;
end = i;
}
if (currentSum < 0) {
currentSum = 0;
tempStart = i + 1;
}
}
if (allNegative) {
cout << "0 0 0" << endl;
} else {
cout << maxSum << " " << start << " " << end << endl;
}
}
return 0;
}
/*示例输入
假设输入序列为：[6, -2, 11, -4, 13, -5, -2, 10]
初始化变量
maxSum = 0：最大子序列的和。
currentSum = 0：当前子序列的和。
start = 0，end = 0：最大子序列的起始和结束位置。
tempStart = 0：当前探索的子序列的潜在起始位置。
allNegative = true：标志位，用来检查数组是否全为负数。
maxElement = nums[0]：数组中的最大元素，用于特殊情况处理。
迭代过程
我们将逐个处理数组中的元素，并调整上述变量：
i = 0 (num = 6)
currentSum = 6 (0 + 6)
maxSum 更新为 6 (因为 currentSum > maxSum)
start = 0, end = 0 （更新最大子序列的起始和结束索引）
allNegative = false （至少有一个非负数）
i = 1 (num = -2)
currentSum = 4 (6 - 2)
maxSum 保持 6
i = 2 (num = 11)
currentSum = 15 (4 + 11)
maxSum 更新为 15
start = 0, end = 2 （更新最大子序列的索引）
i = 3 (num = -4)
currentSum = 11 (15 - 4)
maxSum 保持 15
i = 4 (num = 13)
currentSum = 24 (11 + 13)
maxSum 更新为 24
start = 0, end = 4 （更新最大子序列的索引）
i = 5 (num = -5)
currentSum = 19 (24 - 5)
maxSum 保持 24
i = 6 (num = -2)
currentSum = 17 (19 - 2)
maxSum 保持 24
i = 7 (num = 10)
currentSum = 27 (17 + 10)
maxSum 更新为 27
start = 0, end = 7 （更新最大子序列的索引）
输出结果
最终，最大子序列和为 27，开始索引为 0，结束索引为 7。*/DreamJudge 1571 最长连号
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
int dp[100000]={0},a[100000],ans=0;
cin>>n;
for(int i=0;i<n;i++) cin>>a[i];
dp[0]=1;
for(int i=1;i<n;i++)
{
dp[i]=1;
if(a[i]-a[i-1]==1) dp[i]=dp[i-1]+1;
ans=max(ans,dp[i]);
}
cout<<ans;
return 0;
}🧊🧊🧊8.5 背包类问题
背包定义
背包问题是一个经典的问题，给定 N 个物品和一个背包。物品 i 的重量是 Wi,其体积为 Ci，背包的容量为 C。问应该如何选择装入背包的物品，使得装入背包的物品的总重量为最大。
🥥题型总结：
1、简单背包问题，即没有重量属性，只是判断能否刚好装满。
2、01 背包，即要使能装下的前提下重量尽量大。
3、要求输出装入物品的方案或数量。
// 01 背包模板
#include <iostream>
#include <string.h>
using namespace std;
int dp[21][1010];
int w[21], c[21];
int main() {
int N, V;
cin >> N >> V;//输入物品数量 N 背包体积 V
for (int i = 1; i <= N; ++i) {
cin >> w[i] >> c[i];//每个物品的重量 wi 体积 ci
}
//对于一个动态规划来说，最重要的是找到状态转移方程。
//在 01 背包问题中，一个物品要么装要么不装，那么我们可以得出下面的式子
//f[i,j]代表前 i 个物品背包容量最大为 j 最多能装的物品总重量
//f[i,j] = Max{ f[i-1,j-Ci]+Wi( j >= Ci ), f[i-1,j] }
//根据上面的状态转移方程可以写出下面的代码
for (int i = 1; i <= N; ++i) {
for (int j = 0; j <= V; ++j) {
if(j >= c[i]) {
dp[i][j] = max(dp[i - 1][j - c[i]] + w[i], dp[i - 1][j]);
}
else {
dp[i][j] = dp[i-1][j];
}
}
}
//dp[i][j]表示前 i 个物品装在 j 体积的背包中最大的重量
cout << dp[N][V] << endl;
return 0;
}
🥥例题：DreamJudge 1035
这个题其实是 01 背包的简化版，只有一个属性，但是要求刚好装满，只需要在 01 背包的基础上稍作改变，具体看代码：
#include <stdio.h>
#include <string.h>
int main() {
int dp[1005][1005] = {0};//只有 0 和 1 0 表示不可以 1 表示可以
int w[1005];
int s, n;
while (scanf("%d%d", &s, &n) != EOF) {
int i, j;
for (i = 1; i <= n; i++) {
scanf("%d", &w[i]);
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;//前 0 件物品中能拼凑出 0 重量的方案，所以为 1
for (i = 1; i <= n; i++) {
for (j = s; j >= 0; j--) {
if (dp[i - 1][j] == 1) dp[i][j] = 1;
if (j - w[i] >= 0 && dp[i - 1][j - w[i]] == 1) dp[i][j] = 1;
}
}
if (dp[n][s] == 1) printf("YES\n");
else printf("NO\n");
}
return 0;
}🥥练习题目：
DreamJudge 1123 小偷的背包
#include<bits/stdc++.h>
using namespace std;
int main() {
int dp[1005][1005]={0};//只有 0 和 1 0 表示不可以 1 表示可以
int w[1005];
int s,n;
while(cin>>s>>n){
int i,j;
for (i=1;i<=n;i++) cin>>w[i];
memset(dp,0,sizeof(dp));
dp[0][0]=1;//前 0 件物品中能拼凑出 0 重量的方案，所以为 1
for(i=1;i<=n;i++){
for(j=s;j>=0;j--){
if(dp[i-1][j]==1) dp[i][j]=1;
if(j-w[i]>=0&&dp[i-1][j-w[i]]==1) dp[i][j]=1;
}
}
if(dp[n][s]==1) cout<<"yes!"<<endl;
else cout<<"no!"<<endl;
}
return 0;
}DreamJudge 1567 Buyer 🍰
输出贪心最大值+选择的物品
背过这个模板！！！
//摘自N诺用户：考小研
#include<bits/stdc++.h>
using namespace std;
int main() {
int M,N;
while(cin>>M>>N){
int dp[105]={0},w,v;
vector<int> path[1005];//动态更新路径,二维数组
for(int i=1;i<=N;i++){
cin>>w>>v;
for(int j=M;j>=w;j--)
if(dp[j-w]+v>dp[j]){
dp[j]=dp[j-w]+v;
path[j]=path[j-w];
path[j].push_back(i);
}
}
cout<<dp[M]<<endl;
if(dp[M]){
for(int i=0;i<path[M].size();i++) cout<<path[M][i]<<' ';
cout<<endl;
}
}
}DreamJudge 1086 采药
只需输出贪心最大值
#include<bits/stdc++.h>
using namespace std;
int main()
{
int T,M;
cin>>T>>M;
int dp[1005]={0},t,v;
for(int i=1;i<=M;i++)
{
cin>>t>>v;
for(int j=T;j>=t;j--)
{
if(dp[j-t]+v>dp[j]) dp[j]=dp[j-t]+v;
}
}
cout<<dp[T];
return 0;
}🧊🧊🧊8.6 记忆化搜索
记忆化搜索实际上是递归来实现的，但是递归的过程中有许多的结果是被反复计算的，这样会大大降低算法的执行效率。而记忆化搜索是在递归的过程中，将已经计算出来的结果保存起来，当之后的计算用到的时候直接取出结果，避免重复运算，因此极大的提高了算法的效率。记忆化搜索，是最容易写,也是效率较高的一种做法。虽然本质上是 DFS 这种搜索的思路，但其对搜索过的状态进行记录，从而完成对未知状态的推导，实际上也是一种 DP 的思想。
🥥例题：DreamJudge 1568
在搜索的过程中使用记忆化的方式进行剪枝，即将所有处理过的点的答案记录下来，等下次到达这个点的时候可以直接返回答案，而不需要再重复往下递归，因为上一次已经走过这条路了。
#include <bits/stdc++.h>
using namespace std;
int n,m;
int a[105][105];
int dir[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};
int dp[105][105];
// 记忆化搜索保证每个点只会计算一次
int dfs(int x,int y){
if(dp[x][y]) return dp[x][y];//如果访问过则直接返回结果
int maxx = 1;
for(int i = 0; i < 4; i++){
int tx = x + dir[i][0];
int ty = y + dir[i][1];
if(tx>=1&&tx<=n&&ty>=1&&ty<=m&&a[tx][ty]>a[x][y]){
maxx = max(maxx, dfs(tx, ty) + 1); //自底向上的
}
}
dp[x][y] = maxx; //记忆化
return maxx;
}
int main() {
while (cin >> n >> m) {
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
cin >> a[i][j];
int ans = 0;
memset(dp, 0, sizeof(dp));
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= m; j++){
dp[i][j] = dfs(i,j);
ans = max(ans, dp[i][j]);
}
}
cout << ans << endl;
}
return 0;
}🥥记忆化搜索与 dp 的不同点：
dp 需要对每个状态进行遍历，而记忆化搜索则可以排除无用状态。更重要的是，记忆化搜索还可以剪枝，这样一来，就大大降低了时间复杂度。
🧊🧊🧊8.7 字符串相关的动态规划
我们来看最具代表性也是最常考的三个知识点 ：
1、最长公共子串
问题描述：给出两个字符串，找到最长公共子串，并返回其长度。
输入: s = “ABCD”, t = “EABDF”
输出: 2
解释: s 和 t 的最长公共子串为 “AB”
题目解析：
2、最长公共子序列
问题描述：给出两个字符串，找到最长公共子序列(LCS)，返回 LCS 的长度。
输入: s = “ABCD”, t = “EABDF”
输出: 3
解释: s 和 t 的最长公共子序列为 “ABD”
题目解析：
3、字符串相似度/编辑距离
给定两个单词 word1 和 word2，计算出将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：
插入一个字符
删除一个字符
替换一个字符
输入: word1 = “horse”, word2 = “ros”
输出: 3
解释:
horse -> rorse (将’h’ 替换为 ‘r’)
rorse -> rose (删除 ‘r’) rose -> ros (删除 ‘e’)
题目解析：
🥥练习题目：
DreamJudge 1642 字符串区间翻转 🍰
//摘自N诺用户： damowanghwj
#include<bits/stdc++.h>
using namespace std;
const int N = 1e7+5;
int arr[N];
int dp[N];
//char s[N];
int main() {
int n;
// string s;
while (cin >> n) {
string s;
cin >> s;
memset(dp,0,sizeof(dp));
memset(arr,0,sizeof(arr));
int maxx = 0;
int ans = 0;
// int len = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '0') arr[i] = 1;
else arr[i] = -1;
dp[i] = arr[i];
if (s[i] == '1') ans++;
}
for (int i = 1; i < n; i++) {
dp[i] = max(dp[i - 1] + arr[i], arr[i]);
maxx = max(maxx, dp[i]);
}
ans += maxx;
cout << ans << endl;
}
return 0;
}DreamJudge 1730 最长连续公共子序列
#include<bits/stdc++.h>
using namespace std;
int main()
{
string a,b;
int dp[105][105];
while(cin>>a>>b)
{
memset(dp,0,sizeof(dp));
int lena=a.size(),lenb=b.size(),pos,ans=0;
for(int i=1;i<=lena;i++)
{
for(int j=1;j<=lenb;j++)
{
if(a[i-1]==b[j-1])
{
dp[i][j]=dp[i-1][j-1]+1;
}
else dp[i][j]=0;//要求连续，所以这里和模板不一样了
if(dp[i][j]>=ans)
{
ans=dp[i][j];
pos=i;
}
}
}
cout<<ans<<endl<<a.substr(pos-ans,ans)<<endl;
}
return 0;
}完结撒花！！！到这里，高分篇我们就学习完啦~从下一章开始我们就进入满分篇的学习喽~
创作不易，点个赞吧~点赞收藏不迷路，感兴趣的宝子们欢迎关注该专栏~
勤奋努力的宝子们，学习辛苦了！宝子们可以收藏起来慢慢学哦~🌷🌷🌷休息下，我们下部分再见👋( •̀ ω •́ )✧~
627
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
