【C++二分查找】1870. 准时到达的列车最小时速

闻缺陷则喜何志丹

于 2024-08-13 17:00:00 发布

阅读量1k

点赞数 33

文章标签： c++ 算法力扣二分查找最小速度取整

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

版权

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

77 篇文章 0 订阅

订阅专栏

本文涉及的基础知识点

C++二分查找

LeetCode1870. 准时到达的列车最小时速

给你一个浮点数 hour ，表示你到达办公室可用的总通勤时间。要到达办公室，你必须按给定次序乘坐 n 趟列车。另给你一个长度为 n 的整数数组 dist ，其中 dist[i] 表示第 i 趟列车的行驶距离（单位是千米）。
每趟列车均只能在整点发车，所以你可能需要在两趟列车之间等待一段时间。
例如，第 1 趟列车需要 1.5 小时，那你必须再等待 0.5 小时，搭乘在第 2 小时发车的第 2 趟列车。
返回能满足你准时到达办公室所要求全部列车的最小正整数时速（单位：千米每小时），如果无法准时到达，则返回 -1 。
生成的测试用例保证答案不超过 107 ，且 hour 的小数点后最多存在两位数字。

示例 1：
输入：dist = [1,3,2], hour = 6
输出：1
解释：速度为 1 时：

第 1 趟列车运行需要 1/1 = 1 小时。
由于是在整数时间到达，可以立即换乘在第 1 小时发车的列车。第 2 趟列车运行需要 3/1 = 3 小时。
由于是在整数时间到达，可以立即换乘在第 4 小时发车的列车。第 3 趟列车运行需要 2/1 = 2 小时。
你将会恰好在第 6 小时到达。
示例 2：
输入：dist = [1,3,2], hour = 2.7
输出：3
解释：速度为 3 时：
第 1 趟列车运行需要 1/3 = 0.33333 小时。
由于不是在整数时间到达，故需要等待至第 1 小时才能搭乘列车。第 2 趟列车运行需要 3/3 = 1 小时。
由于是在整数时间到达，可以立即换乘在第 2 小时发车的列车。第 3 趟列车运行需要 2/3 = 0.66667 小时。
你将会在第 2.66667 小时到达。
示例 3：
输入：dist = [1,3,2], hour = 1.9
输出：-1
解释：不可能准时到达，因为第 3 趟列车最早是在第 2 小时发车。

提示：
n == dist.length
1 <= n <= 10⁵
1 <= dist[i] <= 10⁵
1 <= hour <= 10⁹
hours 中，小数点后最多存在两位数字

二分查找

为了避免处理小数，距离和时间都乘以100。
二分查找类型：寻找首端。
Check函数参数范围：[1,10⁷]，由于向上取整，所以速度大于最大距离和等于最大距离一样。
Check函数：最后一趟车用时，不是整数，向上取整到整数。非最后一趟车不是100的整数倍，向上取整到100的整数倍。返回总用时是否小于等于llHour。
需要判断无解。

注意

一，2.01实际存储的是2.009999。故需要 hour*100+0.5。
二，所有列车运行的时间需要向上取整。
三，发车时间都需要以100为单位，向上取整。
四，最大速度是10⁷，别忘记了乘以100。

向上取整的详细证明

性质一：f可能有小数，其整数部分为n。则
如果小数部分等于0， f <= x，等效与 n<= x，解都是大于等于n的整数。
否则， f <= x，等效与 n+1<= x，解都是大于等于n+1的整数。
即等效于向上取整(f) <=x
一，计算第二辆列车的发车时间，t1是整数，第二辆车的发车时间为100 $\times$ t1。
need = (float)dis/mid，令need的整数部分除以100为n1，d1=need-100 $\times$ n1。如果d1为0，则t1=n1,否则t1=n1+1 。
二，其它列车的发车时间类似。
三，计算到达时间。令最后一趟车的发车时间t2，到达时间d2 = t2 + (float)dis/mid 。根据性质一，向上取整后，看是否小于等于llHour。

代码

核心代码

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 minSpeedOnTime(vector<int>& dist, double hour) {
				const long long llHour = hour * 100+0.5; //2.01存储的2.009999
				for (auto& n : dist) {
					n *= 100;
				}
				auto Check = [&](int mid) {
					long long need = 0;
					for (int i = 0; i < dist.size();i++) {
						const int n = dist[i];
						long long cur = n / mid + (0 != n % mid);
						if (i+1 != dist.size()) {
							cur = (n/(100*mid)*100) + 100*( 0 != n%(100*mid));
						}
						need += cur;
					}
					return need <= llHour;
				};
				auto ret = CBinarySearch<int>(1, 10'000'000).FindFrist(Check);
				if (!Check(ret)) return -1;
				return ret;
			}
		};

单元测试

vector<int>dist;
		double hour;
		TEST_METHOD(TestMethod11)
		{
			dist = { 1, 3, 2 }, hour = 6;
			auto res = Solution().minSpeedOnTime(dist, hour);
			AssertEx(1, res);
		}
		TEST_METHOD(TestMethod12)
		{
			dist = { 1, 3, 2 }, hour = 2.7;
			auto res = Solution().minSpeedOnTime(dist, hour);
			AssertEx(3, res);
		}
		TEST_METHOD(TestMethod13)
		{
			dist = { 1, 3, 2 }, hour = 1.9;
			auto res = Solution().minSpeedOnTime(dist, hour);
			AssertEx(-1, res);
		}
		TEST_METHOD(TestMethod14)
		{
			dist = { 1, 1, 100'000 }, hour =2.01;
			auto res = Solution().minSpeedOnTime(dist, hour);
			AssertEx(10'000'000, res);
		}
		TEST_METHOD(TestMethod15)
		{
			dist = { 5,3,4,6,2,2,7 }, hour = 10.92;
			auto res = Solution().minSpeedOnTime(dist, hour);
			AssertEx(4, res);
		}

扩展阅读

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