<think>我们
使用动态规划来解决
二维背包问题。状态dp[i][j]表示至少获得i升
氧气和j升
氮气所需的最小重量。
注意：这里的状态是“至少”，意味着我们可以提供超过所需的
氧气或
氮气，但重量要最小。
初始化：dp[0][0]=0，表示没有需求时重量为0；其他状态初始化为
一个很大的数（表示不可达）。
然后，对于每个
气缸（提供a升
氧气，b升
氮气，重量为c），我们更新状态：
对于当前状态
(i, j
)，考虑
使用这个
气缸后，新的
氧气量是i+a（但注意，如果i+a超过需求，我们只需要需求那么多，因为超过部分没有用，但我们可以用需求上限来避免不必要的计算。然而，在状态转移中，我们可以通过将超过需求的部分截断到需求上限来减少状态数。但题目要求至少满足，所以超过需求是可以的，但我们在状态表示中可以用不超过需求上限的状态来优化，但实际上我们只需要记录到需求上限即可，因为超过部分不会降低重量。
因此，我们可以这样设计：
状态转移方程：dp[i][j] = min
(dp[i][j], dp[max
(0, i - a
)][max
(0, j - b
)] + c
)
但是，注意：我们要求的是至少i和j，所以当我们加入
一个气缸（提供a,b）时，那么之前的状态只需要满足至少i-a和j-b即可（如果i-a<0，那么之前状态可以是0，因为负数需求相当于0）。
然而，为了避免状态过多，我们可以将dp数组的大小设置为[m+1][n+1]，然后从大到小更新（类似于
背包问题的倒序更新，防止重复
使用同
一个气缸）。
具体步骤：
1. 初始化dp数组，大小为
(m+1
) x
(n+1
)，所有元素初始化为
一个很大的数（比如INT_MAX/
2），dp[0][0]=0。
2. 遍历每个
气缸（k个）：
for
(int i = m; i >= 0; i--
)
for
(int j = n; j >= 0; j--
)
如果当前状态dp[i][j]不是无穷大，那么考虑
使用当前
气缸后，新的
氧气量 = i + a，新的
氮气量 = j + b。
但是，由于我们只需要满足至少m和n，所以当i+a>m时，我们可以将其视为m（因为超过m的部分我们不需要，而且不会影响后续决策，因为后续决策只关心至少m和n）；同样，当j+b>n时，视为n。
因此，新的状态为：ni = min
(i+a, m
), nj = min
(j+b, n
)
然后更新：dp[ni][nj] = min
(dp[ni][nj], dp[i][j] + c
)
但是注意：上面的顺序遍历会重复
使用同
一个气缸？不对，因为我们是倒序遍历的（从大到小），所以每个
气缸只
使用一次。
然而，另一种常见的做法是：将每个
气缸看作
一个物品，然后
使用二维背包的模板。状态转移也可以这样：
for
(int i = m; i >= 0; i--
)
for
(int j = n; j >= 0; j--
)
// 当前状态
(i,j
)可以由
(i - a, j - b
)转移而来，但要注意不能为负
int pre_i = max
(0, i - a
);
int pre_j = max
(0, j - b
);
dp[i][j] = min
(dp[i][j], dp[pre_i][pre_j] + c
);
两种方法都可以，但第二种更常见，而且更容易理解：即每个
气缸使用一次，更新所有状态。
我们采用第二种方法，因为第一种方法在更新时，我们是从当前状态加上这个
气缸去更新新状态，而第二种是从之前的状态加上这个
气缸来更新当前状态。实际上，第二种方法更符合背包的常规思路。
步骤（第二种方法）：
dp[i][j]：表示至少需要i升
氧气和j升
氮气所需的最小重量。
初始化：dp[0][0]=0，其他为无穷大。
对于每个
气缸（a, b, c）：
从大到小遍历i从m到0，j从n到0：
pre_i = max
(0, i - a
); // 表示在加入这个
气缸之前，至少需要pre_i升
氧气
pre_j = max
(0, j - b
); // 同理
dp[i][j] = min
(dp[i][j], dp[pre_i][pre_j] + c
);
最后输出dp[m][n]
注意：为什么倒序遍历？因为每个
气缸只能用一次，正序会导致同
一个气缸被重复
使用（因为状态更新会依赖前面的状态，而前面的状态可能已经
使用过该
气缸）。倒序可以保证每个
气缸只被
使用一次。
例子：5升氧，60升
氮，
气缸数据如上，我们期望得到
249。
代码实现：
注意：由于m和n都不大（最大
21和79），k最大1000，所以两层循环（m*n）是
21*79=1659，再乘以k（1000）就是1659000，在可接受范围内。
代码：</think>### 解决方案：
二维费用背包问题（01背包）
#### 方法思路
这是
一个经典的
二维费用背包问题（01背包变种）。每个
气缸可以看作
一个物品，提供两种
费用（
氧气和
氮气），并具有价值（重量）。目标是在满足至少所需
氧气量（m）和
氮气量（n）的前提下，最小化
气缸总重量。
关键点：
1. **状态定义**：`dp[i][j]` 表示获得至少 `i` 升
氧气和 `j` 升
氮气所需的最小重量。
2. **状态转移**：对于每个
气缸（
氧气量 `a`，
氮气量 `b`，重量 `c`），更新状态：
- `dp[i][j] = min
(dp[i][j], dp[max
(0, i - a
)][max
(0, j - b
)] + c
)`
3. **倒序更新**：确保每个
气缸只
使用一次（01背包特性）。
4. **边界处理**：当 `i - a < 0` 或 `j - b < 0` 时，
使用 `0` 作为索引（表示已满足该
气体需求）。
#### 代码实现
```cpp
#include <iostream>
#include <vector>
#include <climits>
#include <algorithm>
using namespace std;
int main
() {
int m, n; //
氧气和
氮气需求
cin >> m >> n;
int k; //
气缸数量
cin >> k;
// 初始化DP数组：dp[i][j] = 至少i升
氧气和j升
氮气的最小重量
vector<vector<int>> dp
(m + 1, vector<int>
(n + 1, INT_MAX
));
dp[0][0] = 0; // 基础状态：0升
氧气和0升
氮气重量为0
// 处理每个
气缸
while
(k--
) {
int a, b, c;
cin >> a >> b >> c; // 当前
气缸的
氧气、
氮气、重量
// 倒序更新DP数组（01背包特性）
for
(int i = m; i >= 0; --i
) {
for
(int j = n; j >= 0; --j
) {
// 跳过不可达状态
if
(dp[i][j] == INT_MAX
) continue;
// 计算新状态索引（处理负数索引）
int new_i = min
(m, i + a
); // 不超过需求上限
int new_j = min
(n, j + b
);
// 更新新状态的最小重量
if
(dp[new_i][new_j] > dp[i][j] + c
) {
dp[new_i][new_j] = dp[i][j] + c;
}
}
}
}
cout << dp[m][n] << endl;
return 0;
}
```
#### 代码解释
1. **输入处理**：读取
氧气需求 `m`、
氮气需求 `n` 和
气缸数量 `k`。
2. **DP数组初始化**：
- 创建
二维数组 `dp[m+1][n+1]`，初始值为 `INT_MAX`（表示不可达状态）。
- 设置基础状态 `dp[0][0] = 0`（无
气体需求时重量为0）。
3. **
气缸处理**：
- 对于每个
气缸，读取其
氧气量 `a`、
氮气量 `b` 和重量 `c`。
- **倒序更新状态**（从 `m` 到 `0`，`n` 到 `0`），确保每个
气缸只
使用一次。
4. **状态转移**：
- 计算新状态 `new_i = min
(m, i + a
)` 和 `new_j = min
(n, j + b
)`（避免超过需求上限）。
- 更新新状态的最小重量：`dp[new_i][new_j] = min
(当前值, dp[i][j] + c
)`。
5. **结果输出**：`dp[m][n]` 即为满足需求的最小重量。
#### 复杂度分析
- **时间复杂度**：O
(k × m × n
)，其中 `k` 为
气缸数量，`m` 和 `n` 为
气体需求上限。
- **空间复杂度**：O
(m × n
)，用于存储DP数组。
---
###
最低0.47元/天 解锁文章
扫一扫
636
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
