1）数字三角形

1：顺推

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

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

#include<bits/stdc++.h>
#define x first
#define y secondusing 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--) {// 每一行的元素的个数应该就是ifor(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$ 数组 $memcpy$ 原二维数组，因为加和是直接在原数组上进行操作的，另外用 $p$ 表示前驱数组用来记录路径，在记录时只需要记录在列方向的偏移量即可，比如往右下则 $p[i,j]=1$，往下 $p[i,j]=0$

#include<bits/stdc++.h>
#define x first
#define y secondusing 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--) {// 每一行的元素的个数应该就是ifor(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)$

• 如果不理解状态转移方程，可以 E03 线性DP 最长上升子序列 bilibili $4:00$ 起看该问题的模拟过程

#include<bits/stdc++.h>
#define x first
#define y secondusing 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(nlo{g}^n)$，因为二分查找是 $O(lo{g}^n)$

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

#include<bits/stdc++.h>
#define x first
#define y secondusing 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]\ne b[j]$，且 $a[i],b[j]$ 都不在公共子序列的情况？其实可以把这种情况归为第 $2,3$ 种情况之一

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

• 只要理解了状态转移方程，代码就很简单

#include<bits/stdc++.h>
#define x first
#define y secondusing 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+1m=strlen(b+1);// 初始化 f[0][j]=0,f[i][0]=0,即i和j中有未指向任意元素的指针存在时// 但是全局变量本身初始化为0,所以无需初始化// 枚举字符串afor(int i=1;i<=n;i++) {// 枚举字符串bfor(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$ 用来记录取得 $LCS$ 的路径，注意，只有来自左上方的元素是 $LCS$ 中的元素

#include<bits/stdc++.h>
#define x first
#define y secondusing 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+1m=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]$ 表示序列 $a[\mathrm{1...}i]$ 和 $b[\mathrm{1...}j]$ 的最长公共子序列的长度
• 最长公共子串中 $f[i,j]$ 表示以 $a[i]$ 和 $b[j]$ 为结尾的公共子串的长度

• 则可以得到状态转移方程
  • 若 $a[i]==b[j]$，构成公共子串，$f[i,j]=f[i-1,j-1]+1$
  • 若 $a[i]!=b[j]$，不能构成公共子串，$f[i,j]=0$（为什么不记录为最大值呢？因为串必须是连续的）

#include<bits/stdc++.h>
#define x first
#define y secondusing 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]$ 表示从 $a[\mathrm{1...}i]$ 变成 $b[\mathrm{1...}j]$ 的编辑距离
• 若 $a[i]=b[j]$，$f[i,j]=f[i-1,j-1]$ ：因为新位置 $i$ 和 $j$ 的元素是相等的，无需编辑转移
• 若 $a[i]!=b[j]$
  • 修改，即 $a$ 中前 $i-1$ 项 和 $b$ 中前 $j-1$ 项已然相等，只需要把最后一项修改为 $b[j]$ 即可，所以有 $f[i,j]=f[i-1,j-1]+1$
  • 插入，即 $a$ 中前 $i$ 项和 $b$ 中前 $j-1$ 项相等，只需要再插入一项 $b[j]$ 即可，所以有 $f[i,j]=f[i,j-1]+1$
  • 删除，即 $a$ 中前 $i-1$ 项和 $b$ 中前 $j$ 项相等，但是多了一项，所以有 $f[i,j]=f[i-1,j]+1$
  • 由于属性是取最小值，所以三者中取 $min$ 即可

• 二维数组的常规做法如下，关于滚动数组优化这里不做解释，因为自己都搞得不是很清楚

#include<bits/stdc++.h>
#define x first
#define y secondusing 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;
}