一、计数DP模型
1.1 整数划分
算法思路一:看成完全背包问题
有一个容量为 n n n 的背包,然后有 n n n 个物品,每个物品的体积分别是 1 、 2 、 3 … n 1、2、3 \dots n 1、2、3…n,每种物品的数量不限,求恰好装满背包的方案数。
集合
f
[
i
]
[
j
]
f[i][j]
f[i][j]:从物品
1
∼
i
1 \sim i
1∼i 中选择,使总体积恰好等于
j
j
j 的选择的数量
集合分类
按照从第
i
i
i 个物品中最多选择多少个来划分:
状态计算
- 选择 0 0 0 个: f [ i − 1 ] ] [ j ] f[i-1]][j] f[i−1]][j];
- 选择 1 1 1 个: f [ i − 1 ] [ j − i ] f[i-1][j-i] f[i−1][j−i];
- 选择 2 2 2 个: f [ i − 1 ] [ j − 2 i ] f[i-1][j-2i] f[i−1][j−2i];
- … \dots …
- 选择 s s s 个: f [ i − 1 ] [ j − s × i ] f[i-1][j-s \times i] f[i−1][j−s×i]。
因此,有状态转移方程:
f [ i ] [ j ] = f [ i − 1 ] [ j ] + f [ i − 1 ] [ j − i ] + f [ i − 1 ] [ j − i × 2 ] + ⋯ + f [ i − 1 ] [ j − i × s ] f[i][j] = f[i-1][j] + f[i-1][j-i] + f[i-1][j-i \times 2] + \dots + f[i-1][j-i \times s] f[i][j]=f[i−1][j]+f[i−1][j−i]+f[i−1][j−i×2]+⋯+f[i−1][j−i×s]
解释一下,举个栗子:
比如当
s
=
2
s=2
s=2 时,表示从
1
∼
i
1 \sim i
1∼i 中选择了
2
2
2 个
i
i
i,使其总体积恰好等于
j
j
j,其方案数就等价于从
1
∼
i
−
1
1 \sim i-1
1∼i−1中选择
2
2
2 个
i
i
i,其总体积恰好等于
j
−
2
×
i
j - 2 \times i
j−2×i。
优化
f[i, j] = f[i-1, j] + f[i-1, j-i] + f[i-1, j-i*2] + ... + f[i-1, j-i*s]
f[i, j-i] = f[i-1, j-i] + f[i-1, j-i*2] + ... + f[i-1, j-i*s]
由上可知:f[i, j] = f[i-1, j] + f[i, j-i]
最终状态转移方程为:
f [ i ] [ j ] = f [ i − 1 ] [ j ] + f [ i ] [ j − i ] f[i][j] = f[i-1][j] + f[i][j-i] f[i][j]=f[i−1][j]+f[i][j−i]
注意初始化:
- f [ 0 ] = 1 f[0] = 1 f[0]=1,表示一个数都没有的时候,即选择0个数,总体积为0,这是一种方案。
- f [ 1 ] = f [ 2 ] = ⋯ = f [ n ] = 0 f[1] = f[2] = \dots = f[n] = 0 f[1]=f[2]=⋯=f[n]=0,表示选择 1 ∼ n 1 \sim n 1∼n个数,使其体积恰好为0的方案是不可能的,方案数为0.
下面代码实现过程中使用了完全背包问题的一维状态表示, j j j 的遍历从小到大。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010, mod = 1e9 + 7;
int n;
int f[N];
int main() {
scanf("%d", &n);
f[0] = 1;
for (int i = 1; i <= n; i ++ )
for (int j = i; j <= n; j ++ )
f[j] = (f[j] + f[j - i]) % mod;
printf("%d\n", f[n]);
return 0;
}
算法思路二:
集合
f
[
i
]
[
j
]
f[i][j]
f[i][j]:所有总和是
i
i
i,并且恰好表示成
j
j
j 个数的和的方案数量
集合划分
根据
j
j
j 个数中是否包含了
1
1
1 分成两类:
- ①:总和是 i i i,表示成 j j j 个数的和,并且每个方案的最小值都是 1 1 1 的方案集合。因为每个方案中都有一个 1 1 1,如果将每个方案中的 1 1 1 去掉,则表示成和是 i − 1 , j − 1 i - 1,j - 1 i−1,j−1 个数的和,即 f [ i − 1 ] [ j − 1 ] f[i-1][j-1] f[i−1][j−1];
- ②:总和是 i i i,表示成 j j j 个数的和,并且每个方案的最小值都大于 1 1 1 的方案集合。因为每个数都是大于 1 1 1 的,所以将每个数都减去 1 1 1,每个数仍然大于等于 1 1 1,即仍然是一个正整数,表示为 f [ i − j × 1 ] [ j ] = f [ i − j ] [ j ] f[i-j \times 1][j] = f[i-j][j] f[i−j×1][j]=f[i−j][j];
状态计算
f [ i ] [ j ] = f [ i − 1 ] [ j − 1 ] + f [ i − j ] [ j ] f[i][j] = f[i-1][j-1] + f[i-j][j] f[i][j]=f[i−1][j−1]+f[i−j][j]
方案数目总和 a n s ans ans:
a n s = f [ n ] [ [ 1 ] + f [ n ] [ 2 ] + ⋯ + f [ n ] [ n ] ans = f[n][[1] + f[n][2] + \dots + f[n][n] ans=f[n][[1]+f[n][2]+⋯+f[n][n]
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010, mod = 1e9 + 7;
int n;
int f[N][N];
int main() {
scanf("%d", &n);
f[0][0] = 1;
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= i; j ++ )
f[i][j] = (f[i - 1][j - 1] + f[i - j][j]) % mod;
int res = 0;
for (int i = 1; i <= n; i ++ )
res = (res + f[n][i]) % mod;
printf("%d\n", res);
return 0;
}
二、记忆化搜索模型
2.1 滑雪
集合
f[i, j]
:所有从[i, j]
开始滑的路径长度的最大值
集合划分与状态计算
按上一个格子滑到当前格子[i, j]
的方向来划分:
- 从上面滑过来:
f[i-1][j] + 1
- 从下面滑过来:
f[i+1][j] + 1
- 从右边活过来:
f[i][j+1] + 1
- 从左边滑过来:
f[i][j-1] + 1
我们在计算的时候不能是环形,即图是拓扑图。因为题中要求后一个状态的高度要小于前一个状态的高度,所以一定不存在环。
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 310;
int n, m;
int h[N][N];
int f[N][N];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
int dp(int x, int y)
{
int &v = f[x][y];
if (v != -1) return v;
v = 1;
for (int i = 0; i < 4; i ++ )
{
int a = x + dx[i], b = y + dy[i];
if (a >= 1 && a <= n && b >= 1 && b <= m && h[a][b] < h[x][y])
v = max(v, dp(a, b) + 1);
}
return v;
}
int main()
{
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= m; j ++ )
scanf("%d", &h[i][j]);
memset(f, -1, sizeof f); // 初始化,表示每个结点都没有算过
int res = 0;
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= m; j ++ )
res = max(res, dp(i, j));
printf("%d\n", res);
return 0;
}
2.2 执行操作使两个字符串相等
思路一:记忆化搜索
TLE
class Solution {
public:
int minOperations(string s1, string s2, int x) {
if ((countOnes(s1) % 2) != (countOnes(s2) % 2)) return -1;
return dfs(s1, s2, x, s1.length() - 1, 0, false);
}
private:
int countOnes(const string& s) {
int count = 0;
for (char c: s)
if (c == '1') count ++ ;
return count;
}
// i 表示当前处理位置(从后往前),j 表示有多少个免费的转化机会,pre_rev 表示前一个位置是否发生了转换
int dfs(string& s1, string& s2, int x, int i, int j, bool pre_rev) {
// 边界条件
if (i < 0) {
if (j || pre_rev) return 1e9; // 这里表示不能完成转换
return 0; // 没有字母可以继续操作了
}
if (!pre_rev) {
if (s1[i] == s2[i]) return dfs(s1, s2, x, i - 1, j, false);
} else {
if (s1[i] != s2[i]) return dfs(s1, s2, x, i - 1, j, false);
}
int res = min(dfs(s1, s2, x, i - 1, j + 1, false) + x, dfs(s1, s2, x, i - 1, j, true) + 1);
if (j) res = min(res, dfs(s1, s2, x, i - 1, j - 1, false)); // 第三种方案:消耗一个免费的转换机会
return res;
}
};
思路二:DP