题解 | #【模板】二维费用背包#

题目链接

题目描述

小红有 $N$ 个事件可以分享。对于第 $i$ 个事件，分享需要花费 $t_i$ 分钟时间和 $h_i$ 点精力，并能获得 $p_i$ 点快乐值。小红希望在总耗时不超过 $T$ ，总消耗精力不超过 $H$ 的前提下，选择分享若干事件，使得获得的快乐值总和最大。

输入:

第一行输入一个整数 $N$ ，表示事件数量。
第二行输入两个整数 $T$ 和 $H$ ，表示可用时间和可用精力的上限。
接下来 $N$ 行，每行输入三个整数 $t_i, h_i, p_i$ ，描述第 $i$ 个事件的参数。

输出:

输出一个整数，代表在限制条件内能获得的最大快乐值。

解题思路

本题是一个典型的 二维费用01背包问题。与传统的01背包问题不同，这里每个物品（事件）有两个“费用”或“成本”（时间和精力），而我们要在两个限制条件下求最大价值。

状态定义:
- 我们定义一个二维数组 $dp$ ，其中 $dp[j][k]$ 表示在时间限制为 $j$ 、精力限制为 $k$ 的情况下，所能获得的最大快乐值。
状态转移:
- 对于第 $i$ 个事件（耗时 $t_i$ ，耗精力 $h_i$ ，快乐值 $p_i$ ），我们有两种选择：
  - 不选择 该事件：最大快乐值保持不变，与只考虑前 $i-1$ 个事件时相同。
  - 选择该事件：前提是当前的时间和精力预算足够，即 $j \ge t_i$ 且 $k \ge h_i$ 。如果选择，那么快乐值就是在消耗 $t_i$ 时间和 $h_i$ 精力前的最大快乐值（即 $dp[j - t_i][k - h_i]$ ）基础上，加上当前事件的快乐值 $p_i$ 。
- 因此，状态转移方程为： $dp[j][k] = \max(dp[j][k], dp[j - t_i][k - h_i] + p_i)$
遍历顺序:
- 为了确保每个事件最多只被选择一次（01背包的特性），我们需要对时间和精力这两个维度进行 逆序遍历。
- 遍历顺序如下：
  - 外层循环遍历每个事件 $i$ 从 $0$ 到 $N-1$ 。
  - 中层循环遍历时间 $j$ 从 $T$ 到 $t_i$ 。
  - 内层循环遍历精力 $k$ 从 $H$ 到 $h_i$ 。
初始化:
- 我们需要将 $dp$ 数组全部初始化为0，表示在没有任何预算或不选择任何事件时，快乐值为0。

最终， $dp[T][H]$ 就是我们要求的答案。

代码

c++
java
python

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int N;
    cin >> N;
    int T, H;
    cin >> T >> H;

    vector<vector<long long>> dp(T + 1, vector<long long>(H + 1, 0));

    for (int i = 0; i < N; ++i) {
        int t, h, p;
        cin >> t >> h >> p;
        for (int j = T; j >= t; --j) {
            for (int k = H; k >= h; --k) {
                dp[j][k] = max(dp[j][k], dp[j - t][k - h] + p);
            }
        }
    }

    cout << dp[T][H] << "\n";
    return 0;
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int T = sc.nextInt();
        int H = sc.nextInt();

        long[][] dp = new long[T + 1][H + 1];

        for (int i = 0; i < N; i++) {
            int t = sc.nextInt();
            int h = sc.nextInt();
            int p = sc.nextInt();
            for (int j = T; j >= t; j--) {
                for (int k = H; k >= h; k--) {
                    dp[j][k] = Math.max(dp[j][k], dp[j - t][k - h] + p);
                }
            }
        }

        System.out.println(dp[T][H]);
    }
}

N = int(input())
T, H = map(int, input().split())

dp = [[0] * (H + 1) for _ in range(T + 1)]

for _ in range(N):
    t, h, p = map(int, input().split())
    for j in range(T, t - 1, -1):
        for k in range(H, h - 1, -1):
            dp[j][k] = max(dp[j][k], dp[j - t][k - h] + p)

print(dp[T][H])

算法及复杂度

算法：动态规划 (二维费用01背包)
时间复杂度： $O(N \cdot T \cdot H)$ - 我们需要遍历 $N$ 个事件，对于每个事件，都需要更新大小为 $T \cdot H$ 的 $dp$ 表。
空间复杂度： $O(T \cdot H)$ - 主要开销是 $dp$ 二维数组。