动态规划高阶模型：多维费用背包与卡特兰数应用

1. 动态规划高阶模型：突破维度的艺术

动态规划（DP）作为算法领域的核心思想之一，其魅力在于能够将复杂问题分解为可管理的子问题。在掌握了基础DP模型后，我们需要挑战更高维度的思考方式。本文将深入探讨三种高阶DP模型：多维费用背包、排列数问题和数学DP（以卡特兰数为代表），这些技术不仅是算法竞赛的常客，更是面试中的高频考点。

1.1 为什么需要突破维度？

传统背包问题通常只考虑单一限制条件（如背包容量）。但在现实场景中，决策往往受到多重约束：

• 资源分配问题需要考虑人力、资金双重限制
• 投资组合需要平衡风险和收益
• 生产计划要兼顾时间和成本

这些场景催生了多维DP模型的发展。理解这些高阶技术，你将能够：

1. 解决LeetCode/ACM中的Hard级DP问题
2. 设计更符合业务需求的算法方案
3. 在技术面试中展现深度思考能力

2. 二维费用背包：双重约束下的最优解

2.1 LeetCode 474. 一和零

问题重述

给定二进制字符串数组strs，整数m和n。要求选择尽可能多的字符串，使得所有选中字符串中：

• '0'的总数 ≤ m
• '1'的总数 ≤ n

示例：
输入：strs = ["10","0001","1","0"], m = 5, n = 3
输出：4（全选时：0共4个≤5，1共3个≤3）

2.2 模型解析

这是一个典型的二维费用01背包问题：

• 物品：每个字符串
• 费用1：字符串中'0'的数量（zeros）
• 费用2：字符串中'1'的数量（ones）
• 价值：每个字符串计数为1（求最大数量）

与传统01背包的区别在于，现在有两个"背包容量"需要同时满足。

2.3 状态设计与转移

三维状态定义：
dp[k][i][j] = 前k个字符串中，'0'不超过i个，'1'不超过j个的最大选择数量

状态转移方程：
对于第k个字符串（zeros个0，ones个1）：

1. 不选：dp[k-1][i][j]
2. 选：dp[k-1][i-zeros][j-ones] + 1
   取两者最大值

2.4 代码实现与优化

初始三维实现：

cpp复制class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        int len = strs.size();
        vector<vector<vector<int>>> dp(len+1, 
            vector<vector<int>>(m+1, vector<int>(n+1, 0)));

        for(int k=1; k<=len; k++){
            int zeros = count(strs[k-1].begin(), strs[k-1].end(), '0');
            int ones = strs[k-1].size() - zeros;
            
            for(int i=0; i<=m; i++){
                for(int j=0; j<=n; j++){
                    dp[k][i][j] = dp[k-1][i][j];
                    if(i >= zeros && j >= ones){
                        dp[k][i][j] = max(dp[k][i][j], 
                                         dp[k-1][i-zeros][j-ones] + 1);
                    }
                }
            }
        }
        return dp[len][m][n];
    }
};

空间优化技巧：
观察到状态转移只依赖前一行，可以压缩为二维数组。关键点：

• 两个费用维度都需要逆序遍历
• 确保更新dp[i][j]时使用的是上一轮的值

cpp复制class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m+1, vector<int>(n+1, 0));
        
        for(const auto& s : strs){
            int zeros = count(s.begin(), s.end(), '0');
            int ones = s.size() - zeros;
            
            for(int i=m; i>=zeros; i--){
                for(int j=n; j>=ones; j--){
                    dp[i][j] = max(dp[i][j], dp[i-zeros][j-ones]+1);
                }
            }
        }
        return dp[m][n];
    }
};

2.5 复杂度分析

• 时间复杂度：O(Lmn)，L为字符串数量
• 空间复杂度：
  • 三维：O(Lmn)
  • 优化后：O(m*n)

关键提示：二维费用背包的空间优化必须同时逆序遍历两个费用维度，这是区别于传统背包的重要细节。

3. 带下限的二维费用：LeetCode 879. 盈利计划

3.1 问题描述

有n个员工和一组工作。第i个工作：

• 需要group[i]人
• 产生profit[i]利润
  求满足以下条件的方案数：

1. 使用人数 ≤ n
2. 总利润 ≥ minProfit

3.2 模型特点

这是二维费用背包的变种：

• 人数：上限约束（≤n）
• 利润：下限约束（≥minProfit）
• 求的是方案数而非最大值

3.3 状态设计创新点

关键难点：利润是下限约束，直接表示会导致数组越界（利润可以无限大）

解决方案：
将所有利润≥minProfit的状态压缩到dp[][minProfit]中

状态定义：
dp[k][i][j] = 前k个工作，使用i人，利润至少为j的方案数

状态转移：
对于工作k（需要g人，产生p利润）：

1. 不选：dp[k-1][i][j]
2. 选：dp[k-1][i-g][max(0, j-p)]
   • 当j-p < 0时，说明只要之前利润≥0即可

3.4 代码实现

初始版本：

cpp复制class Solution {
public:
    int profitableSchemes(int n, int minProfit, 
                         vector<int>& group, vector<int>& profit) {
        const int MOD = 1e9+7;
        int len = group.size();
        vector<vector<vector<int>>> dp(len+1, 
            vector<vector<int>>(n+1, vector<int>(minProfit+1, 0)));
        
        // 初始化：0个工作，0人，利润≥0的方案数为1（空集）
        for(int i=0; i<=n; i++) dp[0][i][0] = 1;

        for(int k=1; k<=len; k++){
            int g = group[k-1], p = profit[k-1];
            for(int i=0; i<=n; i++){
                for(int j=0; j<=minProfit; j++){
                    dp[k][i][j] = dp[k-1][i][j];
                    if(i >= g){
                        dp[k][i][j] = (dp[k][i][j] + 
                                      dp[k-1][i-g][max(0, j-p)]) % MOD;
                    }
                }
            }
        }
        return dp[len][n][minProfit];
    }
};

空间优化版：

cpp复制class Solution {
public:
    int profitableSchemes(int n, int minProfit, 
                         vector<int>& group, vector<int>& profit) {
        const int MOD = 1e9+7;
        vector<vector<int>> dp(n+1, vector<int>(minProfit+1, 0));
        
        for(int i=0; i<=n; i++) dp[i][0] = 1;

        for(int k=0; k<group.size(); k++){
            int g = group[k], p = profit[k];
            for(int i=n; i>=g; i--){
                for(int j=minProfit; j>=0; j--){
                    dp[i][j] = (dp[i][j] + dp[i-g][max(0, j-p)]) % MOD;
                }
            }
        }
        return dp[n][minProfit];
    }
};

3.5 关键细节

1. 初始化：dp[0][i][0] = 1 表示空集的方案
2. MOD运算：题目要求对结果取模
3. max(0, j-p)：处理利润下限的核心技巧

4. 排列数问题：顺序敏感的DP

4.1 LeetCode 377. 组合总和 Ⅳ

问题描述

给定不同整数数组nums和目标target，计算和为target的组合数。注意：(1,2)和(2,1)视为不同组合。

4.2 排列与组合的本质区别

在传统完全背包问题（如零钱兑换II）中：

• 外层循环物品，内层循环容量
• 得到的是组合数（顺序无关）

而本题要求排列数，关键在于：

• 对于总和j，最后一个数可以是nums中的任意一个
• 因此需要先遍历容量，再遍历物品

4.3 状态转移分析

dp[j] = 和为j的排列数

转移方程：
dp[j] += dp[j - nums[i]] 对所有nums[i] ≤ j

遍历顺序的重要性：

• 先物品后容量：固定物品顺序，得到组合数
• 先容量后物品：允许任意顺序，得到排列数

4.4 代码实现

cpp复制class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<unsigned long long> dp(target+1, 0);
        dp[0] = 1;
        
        for(int j=1; j<=target; j++){
            for(int num : nums){
                if(j >= num){
                    dp[j] += dp[j - num];
                }
            }
        }
        return dp[target];
    }
};

注意：使用unsigned long long防止中间结果溢出，尽管题目保证最终结果在int范围内。

5. 数学DP：卡特兰数的奥秘

5.1 LeetCode 96. 不同的二叉搜索树

问题描述

给定整数n，求由1...n构成的互不相同的BST数量。

5.2 卡特兰数推导

对于n个节点的BST：

1. 选择根节点i（1≤i≤n）
2. 左子树：由1...i-1构成，共i-1个节点
3. 右子树：由i+1...n构成，共n-i个节点
4. 总数 = Σ (左子树方案 * 右子树方案)

这正好是卡特兰数的递推公式：
C(n) = Σ C(i-1)*C(n-i) for i=1..n

5.3 DP实现

cpp复制class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n+1, 0);
        dp[0] = 1; // 空树
        dp[1] = 1;
        
        for(int i=2; i<=n; i++){
            for(int j=1; j<=i; j++){
                dp[i] += dp[j-1] * dp[i-j];
            }
        }
        return dp[n];
    }
};

5.4 卡特兰数的应用场景

1. 合法的括号组合
2. 栈的出栈序列
3. 二叉树结构计数
4. 不相交的对角线划分

6. 高阶DP的思维框架

经过这些例题，我们可以总结高阶DP的解题模式：

1. 维度扩展：

   • 识别问题中的多个约束条件
   • 为每个约束增加状态维度
   • 示例：二维费用背包增加第二个费用维度

2. 约束转化：

   • 对于下限约束，使用max/min函数处理
   • 示例：利润下限用max(0, j-p)处理

3. 顺序敏感：

   • 排列问题：先遍历背包容量
   • 组合问题：先遍历物品

4. 数学模型：

   • 识别问题背后的数学序列（如卡特兰数）
   • 建立递推关系

6.1 实战技巧清单

7. 从理论到实践的跨越

理解这些高阶DP模型后，建议通过以下步骤巩固：

1. 重做例题：在不看解答的情况下重新实现
2. 变式训练：
   • 修改"一和零"为求最小字符串数
   • 将"盈利计划"改为求最大利润方案
3. 扩展问题：
   • LeetCode 1155. 掷骰子等于目标和的方法数
   • LeetCode 1449. 数位成本和为目标值的最大数字

记住，DP能力的提升在于：

• 对状态设计的深刻理解
• 对边界条件的谨慎处理
• 大量的刻意练习

当你能够自如地处理这些多维、多约束的DP问题时，就已经站在了算法能力的上层梯队。保持练习，这些技术终将成为你解决复杂问题的利器。