1870-准时到达的列车最小时速

给你一个浮点数 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 <= 105
• 1 <= dist[i] <= 105
• 1 <= hour <= 109
• hours 中，小数点后最多存在两位数字

方法一：二分查找

提示 1

随着火车时速增加，到达终点的时间会减小。

思路与算法

根据 提示 1，我们可以用二分的方法寻找到能够按时到达的最小时速。

由于时速必须为正整数，因此二分的下界为 1；对于二分的上界，我们考虑 hours 为两位小数，因此对于最后一段路程，最小的时限为 0.01，那么最高的时速要求即为 dist}[i]/0.01 \le 10^7，同时为二分时速的上界。

在二分过程中，假设当前时速为 mid，我们计算对应时速下到达终点的时间 t，并与 hour 比较以判断能否按时到达。

假设 dist 的长度为 n，我们考虑第 i 段花费的时间。对于前 n - 1 段，我们需要加上等待通向下一个地点的火车的时间，因此花费的时间为 \lceil \textit{dist}[i] / \textit{mid} \rceil。而对于最后一段，花费的时间为 dist}[n-1] / \textit{mid。

显然，前 n - 1 段至少需要 n - 1 时间完成，同时最后一段的花费时间必定为正数。因此如果时限 hour} \le n - 1，那么显然无法完成，此时应返回 -1。而只要 hour} > n - 1，那么一定存在符合要求的时速。

细节

在代码实现中，为了避免浮点数造成的潜在误差，我们需要转化为整数之间的比较。

假设当前时速为 mid，前 n - 1 段花费的时间为 t，那么如果能够准时到达终点，必定有：

t + \textit{dist}[n-1]}{\textit{mid} } \le \textit{hour}.

首先，考虑不等式左边，t 为整数，但 dist}[n-1]/\textit{mid 为分数，因此我们需要在不等式两边同时乘 mid，即可将不等式左边转化为整数：

\textit{mid}\cdot t + \textit{dist}[n-1] \le \textit{mid}\cdot\textit{hour}.

其次，考虑不等式右边，由于时限 hour 为两位小数，因此我们引入 hr} = 100 \textit{hour 以将其转为整数，并在不等式两边同时乘 100：

100(\textit{mid}\cdot t + \textit{dist}[n-1]) \le \textit{mid}\cdot\textit{hr}.

此时，不等式两边均为整数。

代码

[sol1-C++]

class Solution {
public:
    int minSpeedOnTime(vector<int>& dist, double hour) {
        int n = dist.size();
        // 将 hour 乘 100 以转为整数
        long long hr = llround(hour * 100);
        // 时间必须要大于路程段数减 1
        if (hr <= (n - 1) * 100){
            return -1;
        }
        // 二分
        int l = 1;
        int r = 1e7;
        while (l < r){
            int mid = l + (r - l) / 2;
            // 判断当前时速是否满足时限
            long long t = 0;
            // 前 n-1 段中第 i 段贡献的时间： floor(dist[i] / mid)
            for (int i = 0; i < n - 1; ++i){
                t += (dist[i] - 1) / mid + 1;
            }
            // 最后一段贡献的时间： dist[n-1] / mid
            t *= mid;
            t += dist[n-1];
            if (t * 100 <= hr * mid){   // 通分以转化为整数比较
                r = mid;
            }
            else{
                l = mid + 1;
            }
        }
        return l;   // 满足条件的最小时速
    }
};

[sol1-Python3]

class Solution:
    def minSpeedOnTime(self, dist: List[int], hour: float) -> int:
        n = len(dist)
        hr = round(hour * 100)
        # 时间必须要大于路程段数减 1
        if hr <= 100 * (n - 1):
            return -1
        # 判断当前时速是否满足时限
        def check(speed: int) -> bool:
            t = 0
            # 前 n-1 段中第 i 段贡献的时间： floor(dist[i] / mid)
            for i in range(n - 1):
                t += (dist[i] - 1) // speed + 1
            # 最后一段贡献的时间： dist[n-1] / mid
            t *= speed
            t += dist[-1]
            return t * 100 <= hr * speed   # 通分以转化为整数比较
        
        # 二分
        l, r = 1, 10 ** 7
        while l < r:
            mid = l + (r - l) // 2
            if check(mid):
                r = mid
            else:
                l = mid + 1
        return l   # 满足条件的最小时速

复杂度分析

• 时间复杂度：O(n\log(C))，其中 n 为 dist 的长度，C 为二分的上下界之差。每一次二分都需要 O(n) 的时间计算花费的总时间。

• 空间复杂度：O(1)，我们只使用了常数个变量。