第五章 动态规划(11)：计数DP模型、记忆化搜索模型

一、计数DP模型

1.1 整数划分

ACWing 900

算法思路一：看成完全背包问题

有一个容量为 $n$ 的背包，然后有 $n$ 个物品，每个物品的体积分别是 $1、2、3\dots n$，每种物品的数量不限，求恰好装满背包的方案数。

集合
$f[i][j]$：从物品 $1\sim i$ 中选择，使总体积恰好等于 $j$ 的选择的数量

集合分类
按照从第 $i$ 个物品中最多选择多少个来划分：

状态计算

• 选择 $0$ 个：$f[i-1]][j]$;
• 选择 $1$ 个：$f[i-1][j-i]$；
• 选择 $2$ 个：$f[i-1][j-2i]$；
• $\dots$
• 选择 $s$ 个：$f[i-1][j-s\times i]$。

因此，有状态转移方程：

$$f[i][j]=f[i-1][j]+f[i-1][j-i]+f[i-1][j-i\times 2]+\cdots +f[i-1][j-i\times s]$$

解释一下，举个栗子：
比如当 $s=2$ 时，表示从 $1\sim i$ 中选择了 $2$ 个 $i$，使其总体积恰好等于 $j$，其方案数就等价于从 $1\sim i-1$中选择 $2$ 个 $i$，其总体积恰好等于 $j-2\times 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[0]=1$，表示一个数都没有的时候，即选择0个数，总体积为0，这是一种方案。
• $f[1]=f[2]=\cdots =f[n]=0$，表示选择 $1\sim n$个数，使其体积恰好为0的方案是不可能的，方案数为0.

下面代码实现过程中使用了完全背包问题的一维状态表示，$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]$：所有总和是 $i$，并且恰好表示成 $j$ 个数的和的方案数量

集合划分
根据 $j$ 个数中是否包含了 $1$ 分成两类：

• ①：总和是 $i$，表示成 $j$ 个数的和，并且每个方案的最小值都是 $1$ 的方案集合。因为每个方案中都有一个 $1$，如果将每个方案中的 $1$ 去掉，则表示成和是 $i-1，j-1$ 个数的和，即 $f[i-1][j-1]$；
• ②：总和是 $i$，表示成 $j$ 个数的和，并且每个方案的最小值都大于 $1$ 的方案集合。因为每个数都是大于 $1$ 的，所以将每个数都减去 $1$，每个数仍然大于等于 $1$，即仍然是一个正整数，表示为 $f[i-j\times 1][j]=f[i-j][j]$；

状态计算

$$f[i][j]=f[i-1][j-1]+f[i-j][j]$$

方案数目总和 $ans$：

$$ans=f[n][[1]+f[n][2]+\cdots +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 滑雪

ACWing 901

集合
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 执行操作使两个字符串相等

Leetcode 2896

思路一：记忆化搜索

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