Bootstrap

【C++算法】线性DP详解：数字三角形、最长上升子序列、最长公共子序列、最长公共子串、字符串编辑距离

文章目录

1）数字三角形

1：顺推

  • 顺推比较需要注意的问题就是边界问题，因为从上往下推每个元素会用到上方元素和左上方元素
    • 对于某一行的最后一个元素，那么上方的元素是没有被初始化的
    • 对于某一行的第一个元素，那么左上方的元素是没有被初始化的
    • 为了保证这两种情况一定不选择未被初始化的元素，所以首先把 f f f 数组初始化为 − I N F -INF −INF
  • 随后把 f [ 1 , 1 ] f[1,1] f[1,1] 初始化为 a [ 1 , 1 ] a[1,1] a[1,1]，因为从第二行开始计算，这样计算出来的值就是正常值，最后从最后一行的出口中枚举找一个最大值
#include<bits/stdc++.h>
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int,int> PII;

// 解题思路: 

const int N=5e2+5;
const int INF=1e9;
int f[N][N];
int a[N][N];
int n;

int main() {
	cin>>n;
	for(int i=1;i<=n;i++) {
		for(int j=1;j<=i;j++) {
			scanf("%d",&a[i][j]);
		}	
	}
	// 如果顺推,每个元素应该考虑上方和左上方元素
	// 如果当前计算元素的[i,j]刚好i==j即最后一个时,则上方无元素,会遇到边界问题
	// 为了一定不选择这个边界,可以把其初始化为-INF(因为三角形中数字可能有负值)
	// 别忘了左上角,所以ij均从0开始
	for(int i=0;i<=n;i++) {
		for(int j=0;j<=i+1;j++) {
			f[i][j]=-INF;
		}
	}
	f[1][1]=a[1][1]; // 从a[1][1]开始算,边界依然为-INF
	// 从第二行开始
	for(int i=2;i<=n;i++) {
		for(int j=1;j<=i;j++) {
			f[i][j]=max(f[i-1][j]+a[i][j],f[i-1][j-1]+a[i][j]);
		}	
	}
	int ans=INT_MIN;
	// 对出口求最大值,即为最大路径数字和
	for(int i=1;i<=n;i++) {
		ans=max(ans,f[n][i]);
	}
	cout<<ans;
	return 0;
}

2：逆推

  • 从上往下有五个出口，最终要用 O ( n ) O(n) O(n) 的时间来判断谁的值更大，如果从下往上那么出口只有一个，无需比较；并且从下往上逆推不会遇到边界问题，用到的每个元素都刚好有初始值，可以手动模拟一下为什么没有边界问题
#include<bits/stdc++.h>
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int,int> PII;

// 解题思路: 经典数字三角形

const int N=5e2+5;
const int INF=1e9;
int n;
int a[N][N];

int main() {
	// 逆推,从下往上那么出口只有一个,注意元素只从下方和右下方来
	// 从下往上没有边界问题
	cin>>n;
	for(int i=1;i<=n;i++) {
		for(int j=1;j<=i;j++) {
			scanf("%d",&a[i][j]);
		}	
	}
	// 从倒数第二行开始
	for(int i=n-1;i>=1;i--) {
		// 每一行的元素的个数应该就是i
		for(int j=1;j<=i;j++) {
			a[i][j]+=max(a[i+1][j],a[i+1][j+1]);
		}
	}
	cout<<a[1][1]<<endl;
	return 0;
}
  • 若需要输出路径，可以用 b b b 数组 m e m c p y memcpy memcpy 原二维数组，因为加和是直接在原数组上进行操作的，另外用 p p p 表示前驱数组用来记录路径，在记录时只需要记录在列方向的偏移量即可，比如往右下则 p [ i , j ] = 1 p[i,j]=1 p[i,j]=1，往下 p [ i , j ] = 0 p[i,j]=0 p[i,j]=0
#include<bits/stdc++.h>
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int,int> PII;

// 解题思路: 经典数字三角形

const int N=5e2+5;
const int INF=1e9;
int n;
int a[N][N];

int p[N][N]; // 记录最大值路径
int b[N][N]; // 备份数组,路径跟踪

int main() {
	// 逆推,从下往上那么出口只有一个,注意元素只从下方和右下方来
	// 从下往上没有边界问题
	cin>>n;
	for(int i=1;i<=n;i++) {
		for(int j=1;j<=i;j++) {
			scanf("%d",&a[i][j]);
		}	
	}
	// 拷贝
	memcpy(b,a,sizeof a); // 从a拷到b
	
	// 从倒数第二行开始
	for(int i=n-1;i>=1;i--) {
		// 每一行的元素的个数应该就是i
		for(int j=1;j<=i;j++) {
//			a[i][j]+=max(a[i+1][j],a[i+1][j+1]);
			if(a[i+1][j]>=a[i+1][j+1]) {
				a[i][j]+=a[i+1][j];
				p[i][j]=0; // 来自下方,y轴增量为0
			} else {
				a[i][j]+=a[i+1][j+1];
				p[i][j]=1; // 来自右下,y轴增量为1
			}
		}
	}
	cout<<a[1][1]<<endl;
	int i,j;
	// 输出最大数的路径(行数一直增大,列数根据存储的增量变化)
	for(i=1,j=1;i<=n-1;i++) {
		cout<<b[i][j]<<"->";
		j+=p[i][j];
	}
	cout<<b[n][j];
	return 0;
}

2）最长上升子序列

1：线性DP做法

时间复杂度： O ( n 2 ) O(n^2) O(n2)

#include<bits/stdc++.h>
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int,int> PII;

// 解题思路: 

const int N=1e5+5;
int a[N];
int f[N]; // 以第i个元素结尾的LIS(最长上升子序列)长度
int n;

int main() {
	cin>>n;
	for(int i=1;i<=n;i++) {
		scanf("%d",&a[i]);	
	}
	int res=INT_MIN;
	for(int i=1;i<=n;i++) {
		f[i]=1; // 所有元素起码可以以自身结尾
		// 遍历i之前的元素,如果比i小则可以拼接
		for(int j=1;j<=i;j++) {
			// 不理解可以看视频中的模拟过程
			if(a[j]<a[i]) {
				f[i]=max(f[i],f[j]+1);
			}
		}
		res=max(res,f[i]);
	}
	cout<<res<<endl;
	return 0;
}

2：二分优化

时间复杂度： O ( n l o g n ) O(nlog^n) O(nlogn)，因为二分查找是 O ( l o g n ) O(log^n) O(logn)

  • 模拟过程在 E04 线性DP 最长上升子序列 二分优化 bilibili 6 : 15 6:15 6:15 起
  • 唯一比较疑惑的地方在于，为什么是找到第一个大于等于 a [ i ] a[i] a[i] 的元素做替换而不是大于呢？翻了一下评论区搞明白了，比如 { 1   2   6   7   2   3 } \{1\ 2\ 6\ 7\ 2\ 3\} {1 2 6 7 2 3} 的话，如果大于 x x x，那么序列中可能出现重复元素，最长上升子序列为 1   2   2   3 1\ 2\ 2\ 3 1 2 2 3，这样就不是严格单调递增的了
#include<bits/stdc++.h>
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int,int> PII;

// 解题思路: 

const int N=1e5+5;
int a[N];
int b[N]; // 有序子序列
int len;
int n;

int main() {
	cin>>n;
	for(int i=1;i<=n;i++) {
		scanf("%d",&a[i]);	
	}
	// 遍历a中每一个元素,构造有序子序列
	len=1;
	b[1]=a[1];
	// 1)如果a中元素大于b中最后一个元素,则添加到末尾
	// 2)如果a中元素小于等于b中最后一个元素,则在b数组中找到第一个大于等于a的元素进行替换
	// 比如a[i]替换掉b[j]后,b[j]变小,则b[1...j]的结尾元素更小,则更可能续其他元素,使ILS更大
	for(int i=2;i<=n;i++) {
		if(a[i]>b[len]) {
			b[++len]=a[i];
		} else {
			// 用二分找到第一个大于等于a[i]的元素(答案在左边,压缩右边界)
			int l=1,r=len;
			while(l<=r) {
				int mid=l+r>>1;
				if(b[mid]>=a[i]) {
					r=mid-1;
				} else {
					l=mid+1;
				}
			}
			// l是答案
			b[l]=a[i];
		}
	}
	// 最终len的长度就是答案
	cout<<len<<endl;
	return 0;
}

3）最长公共子序列

  • 为什么没有 a [ i ] ≠ b [ j ] a[i]≠b[j] a[i]=b[j]，且 a [ i ] ,   b [ j ] a[i],\ b[j] a[i], b[j] 都不在公共子序列的情况？其实可以把这种情况归为第 2 ,   3 2,\ 3 2, 3 种情况之一

在这里插入图片描述

  • 一边 d p dp dp 一边打标记记录状态转移，其中从左上方转移过来的元素即为 L C S LCS LCS 中的公共元素

在这里插入图片描述

  • 只要理解了状态转移方程，代码就很简单
#include<bits/stdc++.h>
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int,int> PII;

// 解题思路: 

const int N=1e3+5; // 字符串最大长度
int f[N][N]; // f[i][j]:序列a[1...i]和b[1...j]的最长公共子序列的长度(LCS)
char a[N],b[N];
int n,m;

int main() {
	cin>>a+1>>b+1; // 从下标1开始存储
	n=strlen(a+1); // 起始位置是a+1
	m=strlen(b+1);
	// 初始化 f[0][j]=0,f[i][0]=0,即i和j中有未指向任意元素的指针存在时
    // 但是全局变量本身初始化为0,所以无需初始化
    // 枚举字符串a
	for(int i=1;i<=n;i++) {
        // 枚举字符串b
		for(int j=1;j<=m;j++) {
			if(a[i]==b[j]) {
				f[i][j]=f[i-1][j-1]+1;
			} else {
				f[i][j]=max(f[i-1][j],f[i][j-1]);
			}
		}
	}
	cout<<f[n][m];
	return 0;
}
  • 如果要带路径输出呢？同理，开一个数组 p p p 用来记录取得 L C S LCS LCS 的路径，注意，只有来自左上方的元素是 L C S LCS LCS 中的元素
#include<bits/stdc++.h>
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int,int> PII;

// 解题思路: 

const int N=1e3+5; // 字符串最大长度
int f[N][N]; // f[i][j]:序列a[1...i]和b[1...j]的最长公共子序列的长度(LCS)
char a[N],b[N];
int p[N][N]; // 前驱数组
int n,m;

int main() {
	cin>>a+1>>b+1; // 从下标1开始存储
	n=strlen(a+1); // 起始位置是a+1
	m=strlen(b+1);
	// 初始化 f[0][j]=0,f[i][0]=0,即i和j中有未指向任意元素的指针存在时
	
	for(int i=1;i<=n;i++) {
		for(int j=1;j<=m;j++) {
			if(a[i]==b[j]) {
				f[i][j]=f[i-1][j-1]+1;
				p[i][j]=1; // 来自↖
			} else if(f[i-1][j]>f[i][j-1]) {
				f[i][j]=f[i-1][j];
				p[i][j]=2; // 来自←
			} else {
				f[i][j]=f[i][j-1];
				p[i][j]=3; // 来自↑
			}
		}
	}
	cout<<f[n][m]<<endl; // 最长长度
	int i=n,j=m,k=f[n][m];
	vector<char> path;
	// i或j中任意一个元素=0时退出
	while(i>0 && j>0) {
		// 左上方
		if(p[i][j]==1) {
			path.push_back(a[i]); // LCS中
			i--,j--;
		} 
		// 上方
		else if(p[i][j]==2) {
			i--;
		}
		// 左方
		else {
			j--;
		}
	}
	reverse(path.begin(),path.end());
	for(auto x:path) {
		cout<<x<<' ';
	}
	cout<<endl;
	return 0;
}

4）最长公共子串

  • 这一题和上一题有什么区别呢？序列可以是不连续的，但是串一定是连续的，区别就在此
  • 最长公共子序列中 f [ i , j ] f[i,j] f[i,j] 表示序列 a [ 1... i ] a[1...i] a[1...i] 和 b [ 1... j ] b[1...j] b[1...j] 的最长公共子序列的长度
  • 最长公共子串中 f [ i , j ] f[i,j] f[i,j] 表示以 a [ i ] a[i] a[i] 和 b [ j ] b[j] b[j] 为结尾的公共子串的长度

在这里插入图片描述

在这里插入图片描述

  • 则可以得到状态转移方程
    • 若 a [ i ] = = b [ j ] a[i]==b[j] a[i]==b[j]，构成公共子串， f [ i , j ] = f [ i − 1 , j − 1 ] + 1 f[i,j]=f[i-1,j-1]+1 f[i,j]=f[i−1,j−1]+1
    • 若 a [ i ] ! = b [ j ] a[i]!=b[j] a[i]!=b[j]，不能构成公共子串， f [ i , j ] = 0 f[i,j]=0 f[i,j]=0（为什么不记录为最大值呢？因为串必须是连续的）
#include<bits/stdc++.h>
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int,int> PII;

// 解题思路: 

const int N=1e3+5;
int n,m;
char a[N],b[N];
int f[N][N]; // 以a[i]和b[j]结尾的最长公共子串的长度

int main() {
	cin>>a+1>>b+1;
	n=strlen(a+1);
	m=strlen(b+1);
	// 无需初始化,全局变量
	int ans=INT_MIN;
	for(int i=1;i<=n;i++) {
		for(int j=1;j<=m;j++) {
			// 必须要连续才相加
			if(a[i]==b[j]) {
				f[i][j]=f[i-1][j-1]+1;
			} else {
				f[i][j]=0;
			}
			ans=max(ans,f[i][j]);
		} 
	}
	// 以最后一个元素结尾的不一定是最长公共子串的长度
	cout<<ans<<endl;
	return 0;
}

5）字符串编辑距离

  • f [ i , j ] f[i,j] f[i,j] 表示从 a [ 1... i ] a[1...i] a[1...i] 变成 b [ 1... j ] b[1...j] b[1...j] 的编辑距离
  • 若 a [ i ] = b [ j ] a[i]=b[j] a[i]=b[j]， f [ i , j ] = f [ i − 1 , j − 1 ] f[i,j]=f[i-1,j-1] f[i,j]=f[i−1,j−1] ：因为新位置 i i i 和 j j j 的元素是相等的，无需编辑转移
  • 若 a [ i ] ! = b [ j ] a[i]!=b[j] a[i]!=b[j]
    • 修改，即 a a a 中前 i − 1 i-1 i−1 项 和 b b b 中前 j − 1 j-1 j−1 项已然相等，只需要把最后一项修改为 b [ j ] b[j] b[j] 即可，所以有 f [ i , j ] = f [ i − 1 , j − 1 ] + 1 f[i,j]=f[i-1,j-1]+1 f[i,j]=f[i−1,j−1]+1
    • 插入，即 a a a 中前 i i i 项和 b b b 中前 j − 1 j-1 j−1 项相等，只需要再插入一项 b [ j ] b[j] b[j] 即可，所以有 f [ i , j ] = f [ i , j − 1 ] + 1 f[i,j]=f[i,j-1]+1 f[i,j]=f[i,j−1]+1
    • 删除，即 a a a 中前 i − 1 i-1 i−1 项和 b b b 中前 j j j 项相等，但是多了一项，所以有 f [ i , j ] = f [ i − 1 , j ] + 1 f[i,j]=f[i-1,j]+1 f[i,j]=f[i−1,j]+1
    • 由于属性是取最小值，所以三者中取 m i n min min 即可

在这里插入图片描述

  • 二维数组的常规做法如下，关于滚动数组优化这里不做解释，因为自己都搞得不是很清楚
#include<bits/stdc++.h>
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int,int> PII;

// 解题思路: 

const int N=1e3+5;
int n,m;
char a[N],b[N];
int f[N][N];

int main() {
	cin>>a+1>>b+1;
	n=strlen(a+1);
	m=strlen(b+1);
	// 从a[1...i]变成空串,需要是删除i次
	for(int i=1;i<=n;i++) {
		f[i][0]=i;
	}
	// 从空串变成b[1...j],需要添加j次
	for(int j=1;j<=m;j++) {
		f[0][j]=j;
	}
	// 状态转移
	// 如果记录一下状态转移就可以输出变化过程
	for(int i=1;i<=n;i++) {
		for(int j=1;j<=m;j++) {
			// 末尾相等,无需添加
			if(a[i]==b[i]) {
				f[i][j]=f[i-1][j-1];
			} else {
				f[i][j]=min(f[i-1][j],min(f[i][j-1],f[i-1][j-1]))+1; // 三种操作的最小值
			}
		}	
	}
	cout<<f[n][m]<<endl;
	return 0;
}

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
Docker 内存资源的限制
【ESP32 IDF SPI硬件驱动W25Q64】
MySQL权限操作
【JS】import 、import() 与 @import 的区别
python os模块 、glob模块 、shutil模块
MySql中的连接查询
ELK日志收集
看看新风向——游戏是人工智能研究的理想场景
嘘！禁止想象（各大厂都爱考的一道编程题，你们知道吗？）
【工厂方法模式】深度解析：从原理到实战的全方位指南（开发者必备）
;