【C++二分查找】2861. 最大合金数

最新推荐文章于 2024-10-12 09:09:57 发布

闻缺陷则喜何志丹

最新推荐文章于 2024-10-12 09:09:57 发布

阅读量931

点赞数 30

文章标签： c++ 算法力扣二分查找最大合金数机器

本文链接：https://blog.csdn.net/he_zhidan/article/details/141503289

版权

工作级难度算法题解专栏收录该内容

129 篇文章 0 订阅

订阅专栏

本文涉及的基础知识点

C++二分查找

LeetCode2861. 最大合金数

假设你是一家合金制造公司的老板，你的公司使用多种金属来制造合金。现在共有 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 <= 10⁸
composition.length == k
composition[i].length == n
1 <= composition[i][j] <= 100
stock.length == cost.length == n
0 <= stock[i] <= 10⁸
1 <= cost[i] <= 100

C++二分查找

枚举各机器，时间复杂度：O(k)，二分此机器的产量，时间复杂度O(log2e8)。总时间复杂度：O(klog(2e8))
二分类型：寻找末端。
Check函数范围：[0,2e8]
Check函数：
need记录需要的钱数;累加各原料需要的购买的钱数：max(0,(com[j]*mid-stock[j])*cost[j])
return need <= budget

代码

核心代码

template<class INDEX_TYPE>
class CBinarySearch
{
public:
	CBinarySearch(INDEX_TYPE iMinIndex, INDEX_TYPE iMaxIndex):m_iMin(iMinIndex),m_iMax(iMaxIndex) {}
	template<class _Pr>
	INDEX_TYPE FindFrist( _Pr pr)
	{
		auto left = m_iMin - 1;
		auto rightInclue = m_iMax;
		while (rightInclue - left > 1)
		{
			const auto mid = left + (rightInclue - left) / 2;
			if (pr(mid))
			{
				rightInclue = mid;
			}
			else
			{
				left = mid;
			}
		}
		return rightInclue;
	}
	template<class _Pr>
	INDEX_TYPE FindEnd( _Pr pr)
	{
		int leftInclude = m_iMin;
		int right = m_iMax + 1;
		while (right - leftInclude > 1)
		{
			const auto mid = leftInclude + (right - leftInclude) / 2;
			if (pr(mid))
			{
				leftInclude = mid;
			}
			else
			{
				right = mid;
			}
		}
		return leftInclude;
	}
protected:
	const INDEX_TYPE m_iMin, m_iMax;
};

class Solution {
		public:
			int maxNumberOfAlloys(int n, int k, int budget, vector<vector<int>>& composition, vector<int>& stock, vector<int>& cost) {
				int iMax = 0;
				auto Do = [&](const vector<int>& com) {
					auto Check = [&](int mid) {
						long long need = 0;
						for (int i = 0; i < n; i++) {
							need += max(0LL, (com[i]*(long long)mid - stock[i]) * (cost[i]));
						}
						return need <= budget;
					};
					int ret = CBinarySearch<int>(0, 2'00'000'000).FindEnd(Check);
					iMax = max(iMax, ret);
				};
				for (const auto& v : composition) { Do(v); }
				return iMax;
			}
		};

单元测试

	int n,  k,  budget;
		vector<int> removable;
		vector<vector<int>> composition;
		vector<int> stock,  cost;
		TEST_METHOD(TestMethod11)
		{
			n = 3, k = 2, budget = 15, composition = { {1,1,1},{1,1,10} }, stock = { 0,0,0 }, cost = { 1,2,3 };
			auto res = Solution().maxNumberOfAlloys(n, k, budget, composition, stock, cost);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod12)
		{
			n = 3, k = 2, budget = 15, composition = { {1,1,1},{1,1,10} }, stock = { 0,0,100 }, cost = { 1,2,3 };
			auto res = Solution().maxNumberOfAlloys(n, k, budget, composition, stock, cost);
			AssertEx(5, res);
		}
		TEST_METHOD(TestMethod13)
		{
			n = 2, k = 3, budget = 10, composition = { {2,1},{1,2},{1,1} }, stock = { 1,1 }, cost = { 5,5 };
			auto res = Solution().maxNumberOfAlloys(n, k, budget, composition, stock, cost);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod14)
		{
			n = 4, k = 4, budget = 17, composition = { {10,10,1,5},{9,7,7,1},{6,3,5,9},{2,10,2,7} }, stock = { 9,8,2,7 }, cost = { 9,2,6,10 };
			auto res = Solution().maxNumberOfAlloys(n, k, budget, composition, stock, cost);
			AssertEx(1, res);
		}

扩展阅读

我想对大家说的话
工作中遇到的问题，可以按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
学习算法：按章节学习《喜缺全书算法册》，大量的题目和测试用例，打包下载。重视操作
有效学习：明确的目标及时的反馈拉伸区（难度合适）专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
失败+反思=成功成功+反思=成功