一、路径类
1. 字母收集
思路:
1、预处理
对输入的字符矩阵我们按照要求将其转换为数字分数,由于只能往下和往右走,因此走到(i,j)的位置要就是从(i - 1, j)往下走,或者是从(i,j - 1)的位置往右走,由于我们要使得路程遍历积分最多,则应该从积分多的位置过来,
2、状态表示 dp[i][j] 表示:从[0, 0]出发,到底[i, j]位置,一共有多少分
3、状态转移方程
故(i,j)位置的积分应该为dp[ i ][ j ] = max(dp[ i - 1 ][ j ], dp[ i ][ j - 1 ]) + dp[ i ][ j ];
4、初始化
但是上面仅对于(i >= 1 && j >= 1)成立,对于第一行和第一列我们应该特殊处理,利用前缀和的知识可以求得,走到第一列的第i个位置最多能拿的积分以及走到第一行的第j个位置最多能拿的积分,然后我们就可以按照dp[ i ][ j ] = max(dp[ i - 1 ][ j ], dp[ i ][ j - 1 ]) + dp[ i ][ j ]的方法遍历每个节点即可
#include <iostream>
using namespace std;
const int N = 1005;
int dp[N][N];
int main() {
int n, m;
cin >> n >> m;
char ch;
for (int i = 0; i < n; i++){
for (int j = 0; j < m; j++){
cin >> ch;
if (ch == 'l') dp[i][j] = 4;
else if (ch == 'o') dp[i][j] = 3;
else if (ch == 'v') dp[i][j] = 2;
else if (ch == 'e') dp[i][j] = 1;
else a[i][j] = 0;
}
}
for (int i = 1; i < n; i++) dp[i][0] = dp[i - 1][0] + dp[i][0];
for (int j = 1; j < m; j++) dp[0][j] = dp[0][j - 1] + dp[0][j];
for (int i = 1; i < n; i++){
for (int j = 1; j < m; j++){
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + dp[i][j];
}
}
cout << dp[n - 1][m - 1] << endl;
return 0;
}
2、[NOIP2002 普及组] 过河卒
分析:
思路:
1、状态表示
dp[i][j] 表示:从[0, 0]出发,到底[i, j]位置,一共有多少种方法
2、状态转移方程dp[ i ][ j ] = dp[ i - 1 ][ j ] + dp[i][j - 1] (i > 0 && j > 0)
当走到马可以走的地方,dp[ i ][ j ] = 0;
3、初始化先创建一个 dp[ n + 2 ][ m + 2 ],然后让dp[ 0 ][ 1 ] = 1 或者 dp[ 1 ][ 0 ] = 1。注意这样初始化的时候,x需要+1,y也需要+1.和dp表位置一一对应
#include <iostream>
#include <vector>
using namespace std;
//int dp[1005][1005];
int main()
{
int n, m, x, y;
cin >> n >> m >> x >> y;
vector<vector<long long>> dp(n + 2, vector<long long>(m + 2));
dp[0][1] = 1;
x += 1, y += 1;和dp表位置一一对应
for (int i = 1; i <= n + 1; i++)
{
for (int j = 1; j <= m + 1; j++) { //马所在位置
if (i != x && j != y && abs(i - x) + abs(j - y) == 3 || (i == x && j == y))
{
dp[i][j] == 0;
}
else dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
}
}
cout << dp[n + 1][m + 1] << endl;
return 0;
}
二、子序列和连续序列类
1. mari和shiny
🌈线性 dp
在维护 i 位置之前,⼀共有多少个 "s" "sh" ,然后更新 "shy" 的个数。
(1)状态表示
s[i]:字符串 str 中 [0, i] 区间内有多少个 "s"。
h[i]:字符串 str 中 [0, i] 区间内有多少个 "sh"。
y[i]:字符串 str 中 [0, i] 区间内有多少个 "shy。
(2)状态转移方程
(3)空间优化
用三个变量来表示即可
s:(字符串 str 中 [0, n-1] 区间内有多少个 "s")
h:(字符串 str 中 [0, n-1] 区间内有多少个 "sh")
y:(字符串 str 中 [0, n-1] 区间内有多少个 "shy")
最后的遍历结束后,y即我们需要的结果
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
int main()
{
int n;
string str;
cin >> n >> str;
ll s = 0, h = 0, y = 0;
for (int i = 0; i < n; i++) {
if (str[i] == 's') s++;
else if (str[i] == 'h') h += s;
else if (str[i] == 'y') y += h;
}
cout << y << endl;
return 0;
}
🌈二维 dp
这道题目如果不是子序列,而是要求连续序列的,那就可以考虑用 KMP。
(1)dp[i][j] 含义
- string t="shy"
dp[i][j]:以 i-1 为结尾的 str 子序列中出现以 j-1 为结尾的 t 的个数为 dp[i][j]。
(2)递推关系
- str[i - 1] 与 t[j - 1]相等
- str[i - 1] 与 t[j - 1] 不相等
当 str[i - 1] 与 t[j - 1]相等时,dp[i][j] 可以有两部分组成:
- 一部分是用 str[i - 1] 来匹配,那么个数为 dp[i - 1][j - 1]。即不需要考虑当前 str 子串和 t 子串的最后一位字母,所以只需要 dp[i-1][j-1]。
- 一部分是不用 str[i - 1] 来匹配,个数为 dp[i - 1][j]。
为什么还要考虑不用 str[i - 1] 来匹配,都相同了指定要匹配?
🧩例如: str:shyy 和 t:shy ,str[3] 和 t[2] 是相同的,但是字符串 str 也可以不用 str[3] 来匹配,即用 str[0]str[1]str[2] 组成的 "shy"。当然也可以用 str[3] 来匹配,即:str[0]str[1]str[3] 组成的 "shy"。所以,当 str[i - 1] 与 t[j - 1] 相等时,dp[ i ][ j ] = dp[ i - 1 ][ j - 1 ] + dp[ i - 1 ][ j ];
当 str[i - 1] 与 t[j - 1] 不相等时,dp[i][j] 只有一部分组成,不用 str[i - 1] 来匹配(就是模拟在 str 中删除这个元素),即:dp[i - 1][j],所以递推公式为:dp[ i ][ j ] = dp[ i - 1 ][ j ];
为什么只考虑 “不用 str[i - 1] 来匹配” 这种情况, 不考虑 “不用 t[j - 1] 来匹配” 的情况呢?
🧩这里要明确,我们求的是 str 中有多少个 t,而不是求 t 中有多少个 str,所以只考虑 str 中删除元素的情况,即不用 str[i - 1] 来匹配 的情况。
(3)状态转移方程
dp[i][j]显然要从dp[i-1][?]递推而来。立即思考dp[i-1][j], dp[i-1][j-1]分别与dp[i][j]的关系。因为少一个字符,自然而然从当前字符着手。考察si的第i个字符(表为s[i])和tj的第j个字符(表为t[j])的关系。
若s[i] ≠ t[j]:那么s_i中的所有t_j子序列,必不包含s[i],即s_i-1和s_i中tj的数量是一样的,得到该情形的转移方程: dp[ i ][ j ] = dp[ i -1 ][ j ]
若s[i] = t[j]:假设s_i中的所有t_j子序列中,包含s[i]的有a个,不包含的有b个。s_i中包含s[i]的子序列个数相当于s_i-1中t_j-1的个数,不包含s[i]的子序列个数与上一种情况一样,于是得到该情形的转移方程:
a = dp[ i -1 ][ j -1 ] b = dp[ i-1 ][ j ] dp[ i ][ j ] = a + b = dp[i-1][j-1] + dp[i-1][j]
(4)遍历顺序
从上到下,从左到右。
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int n;
cin >> n;
string str;
cin >> str;
string t="shy";
int m=t.size();
vector<vector<long long>> dp(n+1, vector<long long>(m+1));
for(int i=0; i<=n; i++) dp[i][0]=1;
for(int i=1; i<=n; i++)
{
for(int j=1; j<=m; j++)
{
if(str[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];
}
}
cout << dp[n][m] << endl;
return 0;
}
2. 不同的子序列
该题于上题不一样的是,上面给定了t的具体字符串,而这里没有给定,但是我们也需要用二维dp的方法来写。
(1)dp[i][j] 含义
s[ i ]的子序列中在t[ j ]出现的次数
s[ i ]表示s从下标 i 到末尾的子字符串。
t[ j ]表示t从下标 j 到末尾的子字符串。
(2)递推关系
- 分别令两个维度为0,推测边界。
- dp[0][j]表示s_0中t_j的个数。s_0是空字符串,只有当j=0时,才有dp[0][j] = 1,表示s子空串中有一个t子空串,否则dp[0][j] = 0,因为一个空串不可能包含一个非空串。
dp[i][0]表示s_i中t0的个数。t_0是空字符串,显然任何串(包括空串)都含有一个空子串。因此dp[i][0] = 1。
注意到,dp[i][0] = 1实际上已经包含了dp[0][j] = 1的情形。
(3)初始化
- dp[i][0] 表示:以 i-1 为结尾的 str 可以随便删除元素,出现空字符串的个数。所以,dp[i][0] 一定都是 1,因为也就是把以 i-1 为结尾的 str,删除所有元素,出现空字符串的个数就是 1。
- dp[0][j] 表示:空字符串 str 可以随便删除元素,出现以 j-1 为结尾的字符串 t 的个数。所以,dp[0][j] 一定都是 0,因为 str 如论如何也变成不了 t。
- dp[0][0] 表示:空字符串 str 可以删除 0 个元素,变成空字符串 t。所以,dp[0][0] = 1。
(4)遍历顺序
从上到下,从左到右。
int numDistinct(string s, string t) {
int n = s.size(), m = t.size();
if (n < m) return 0;
vector<vector<unsigned int>> dp(n + 1, vector<unsigned int>(m + 1)); //注意是unsigned int
for (int i = 0; i <= n; i++) dp[i][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[i][j] = dp[i - 1][j] +(s[i - 1] == t[j - 1] ? dp[i - 1][j - 1] : 0);
}
}
return dp[n][m];
}