2861. 最大合金数
1.题目介绍
假设你是一家合金制造公司的老板，你的公司使用多种金属来制造合金。现在共有 n 种不同类型的金属可以使用，并且你可以使用 k 台机器来制造合金。每台机器都需要特定数量的每种金属来创建合金。
对于第 i 台机器而言，创建合金需要 composition[i][j] 份 j 类型金属。最初，你拥有 stock[i] 份 i 类型金属，而每购入一份 i 类型金属需要花费 cost[i] 的金钱。
给你整数 n、k、budget，下标从 1 开始的二维数组 composition，两个下标从 1 开始的数组 stock 和 cost，请你在预算不超过 budget 金钱的前提下，最大化 公司制造合金的数量。
所有合金都需要由同一台机器制造。返回公司可以制造的最大合金数。
示例 1：
输入：n = 3, k = 2, budget = 15, composition = [[1,1,1],[1,1,10]], stock = [0,0,0], cost = [1,2,3]
输出：2
解释：最优的方法是使用第 1 台机器来制造合金。
要想制造 2 份合金，我们需要购买：
- 2 份第 1 类金属。
- 2 份第 2 类金属。
- 2 份第 3 类金属。
总共需要 2 * 1 + 2 * 2 + 2 * 3 = 12 的金钱，小于等于预算 15 。
注意，我们最开始时候没有任何一类金属，所以必须买齐所有需要的金属。
可以证明在示例条件下最多可以制造 2 份合金。
示例 2：
输入：n = 3, k = 2, budget = 15, composition = [[1,1,1],[1,1,10]], stock = [0,0,100], cost = [1,2,3]
输出：5
解释：最优的方法是使用第 2 台机器来制造合金。
要想制造 5 份合金，我们需要购买：
- 5 份第 1 类金属。
- 5 份第 2 类金属。
- 0 份第 3 类金属。
总共需要 5 * 1 + 5 * 2 + 0 * 3 = 15 的金钱，小于等于预算 15 。
可以证明在示例条件下最多可以制造 5 份合金。
示例 3：
输入：n = 2, k = 3, budget = 10, composition = [[2,1],[1,2],[1,1]], stock = [1,1], cost = [5,5]
输出：2
解释：最优的方法是使用第 3 台机器来制造合金。
要想制造 2 份合金，我们需要购买：
- 1 份第 1 类金属。
- 1 份第 2 类金属。
总共需要 1 * 5 + 1 * 5 = 10 的金钱，小于等于预算 10 。
可以证明在示例条件下最多可以制造 2 份合金。
提示：
1 <= n, k <= 100
0 <= budget <= 108
composition.length == k
composition[i].length == n
1 <= composition[i][j] <= 100
stock.length == cost.length == n
0 <= stock[i] <= 108
1 <= cost[i] <= 100
2.题解
2.1 二分法
思路
1.这里0 <= stock[i] <= 10e8 且 1 <= composition[i][j] <= 100 && 1 <= cost[i] <= 100 加上 0 <= budget <= 10e8 即最多买10e8 / 1 = 10e8个金属
即使极端情况，stock[i] = 10e8, budget <= 10e8， composition[i][j] = 1且只有一个j， cost[j] = 1; 最多最多也只能造出 2*10e8 个金属
由此可以确定上界。
2.由题目介绍：所有合金都需要由同一台机器制造。首先我们可以枚举具体使用的是哪台机器，之后确定二分上下界开始二分查找能造出的最大金属数量
3.这里要注意 composition[i][j]) * mid 在计算的时候会导致中间结果超出 int范围导致溢出，
所以我们这里选择使用强制类型转换，将其中一个变量由int转换为long long,这样中间结果会存在一个long long的临时变量中，就不会发生溢出。
这里使用static_cast方法来进行强转
4.正常的二分过程就不赘述了
代码
class Solution {
public:
int maxNumberOfAlloys(int n, int k, int budget, vector<vector<int>>& composition, vector<int>& stock, vector<int>& cost) {
int ans = 0;
for(int i = 0; i < k; i++){ //确定选用哪台机器
int left = 1, right = 2e8;
while(left <= right){
int mid = left + (right - left) / 2;
long long spend = 0;
for(int j = 0; j < n; j++) //确定每种金属花费量
spend += max(static_cast<long long>(composition[i][j]) * mid - stock[j], 0LL) * cost[j];
if (spend <= budget){
ans = max(ans, mid);
left = mid + 1;
}
else
right = mid - 1;
}
}
return ans;
}
};
2.2 优化二分版本
思路
1.这里首先缩小二分上界，我们之前的2*10e8怎么来的，假设只需要一种金属[j]，且至少需要一块（由于 composition[i][j] >=1）,假设生成合金就只要一块
然后还可以购买嘛，假设这种金属最便宜情况， cost[j] = 1, 所以可以购买 budget 个金属， 多生成 budget 块合金。
{考虑到实际还需要其他种类金属，且价格肯定也不止1，其他情况肯定生成的合金更少！！！}
故生成最大合金量 = min(stock[j]) + budget; {这里肯定是要以最小存储量决定最大合金量，最小的都满足了其他存储更多的肯定满足，反之不满足}
其次可以缩小二分下界，我们每次算出来一个最大ans，我们肯定希望后续结果肯定是要大于这个值的，所以不必再从0开始，直接从ans开始即可。
2.这里使用了Lambda函数，check 是一个函数对象，具体来说是 lambda 表达式创建的闭包类型。
这里捕获参数num就已经转换为了long long,所以在下面的计算中不需要再强转了
check函数是用来判断二分输入的中间值mid块合金，生产成本能否在预算budget之内。
3. 由以下代码可以确定，这是一个开区间写法，在(ans, mx+1)中寻找，结束是在(l,r=l+1)
int l = ans, r = mx + 1, mid;
while (l + 1 < r) {}
重新确定范围
(check(mid) ? l : r) = mid;
如果 check(mid) 为真，则更新 l 为 mid，（mid, r）; 否则更新 r 为 mid (l, mid)。
4.最终结果其实是在(l, r = l + 1)之间，但是由于合金个数必须为整数，向下取整为ans = l
代码
class Solution {
public:
int maxNumberOfAlloys(int n, int k, int budget, vector<vector<int>>& composition, vector<int>& stock, vector<int>& cost) {
int ans = 0, mx = ranges::min(stock) + budget;
for (auto& c : composition) {
// 在这个过程中，去检查还需要多少合金 - num : 合金份数
auto check = [&](long long num) -> bool {
long long money = 0, tmp;
for (int i = 0; i < n; ++i) {
if ((tmp = num * c[i] - stock[i]) > 0) {
money += tmp * cost[i];
if (money > budget) {
return false;
}
}
}
return true;
};
int l = ans, r = mx + 1, mid;
while (l + 1 < r) {
mid = (l + r) >> 1;
(check(mid) ? l : r) = mid;
}
ans = l;
}
return ans;
}
};
