Formatted question description: https://leetcode.ca/all/1870.html

# 1870. Minimum Speed to Arrive on Time

## Level

Medium

## Description

You are given a floating-point number `hour`

, representing the amount of time you have to reach the office. To commute to the office, you must take `n`

trains in sequential order. You are also given an integer array `dist`

of length `n`

, where `dist[i]`

describes the distance (in kilometers) of the `i-th`

train ride.

Each train can only depart at an integer hour, so you may need to wait in between each train ride.

- For example, if the
`1st`

train ride takes`1.5`

hours, you must wait for an additional`0.5`

hours before you can depart on the`2nd`

train ride at the 2 hour mark.

Return *the minimum positive integer speed (in kilometers per hour) that all the trains must travel at for you to reach the office on time, or *.

`-1`

if it is impossible to be on timeTests are generated such that the answer will not exceed `10^7`

and `hour`

will have **at most two digits after the decimal point**.

**Example 1:**

**Input:** dist = [1,3,2], hour = 6

**Output:** 1

**Explanation:** At speed 1:

- The first train ride takes 1/1 = 1 hour.
- Since we are already at an integer hour, we depart immediately at the 1 hour mark. The second train takes 3/1 = 3 hours.
- Since we are already at an integer hour, we depart immediately at the 4 hour mark. The third train takes 2/1 = 2 hours.
- You will arrive at exactly the 6 hour mark.

**Example 2:**

**Input:** dist = [1,3,2], hour = 2.7

**Output:** 3

**Explanation:** At speed 3:

- The first train ride takes 1/3 = 0.33333 hours.
- Since we are not at an integer hour, we wait until the 1 hour mark to depart. The second train ride takes 3/3 = 1 hour.
- Since we are already at an integer hour, we depart immediately at the 2 hour mark. The third train takes 2/3 = 0.66667 hours.
- You will arrive at the 2.66667 hour mark.

**Example 3:**

**Input:** dist = [1,3,2], hour = 1.9

**Output:** -1

**Explanation:** It is impossible because the earliest the third train can depart is at the 2 hour mark.

**Constraints:**

`n == dist.length`

`1 <= n <= 10^5`

`1 <= dist[i] <= 10^5`

`1 <= hour <= 10^9`

- There will be at most two digits after the decimal point in
`hour`

.

## Solution

The maximum possible speed is `10^7`

. If it is still impossible to arrive on time using the maximum possible speed, return -1. Then let `high = 10000000`

and `low = 1`

, and use binary search to find the minimum speed to arrive on time.

```
class Solution {
public int minSpeedOnTime(int[] dist, double hour) {
int high = 10000000;
if (!canArrive(dist, hour, high))
return -1;
int low = 1;
while (low < high) {
int mid = (high - low) / 2 + low;
if (canArrive(dist, hour, mid))
high = mid;
else
low = mid + 1;
}
return low;
}
public boolean canArrive(int[] dist, double hour, int speed) {
double total = 0;
int length = dist.length;
for (int i = 0; i < length; i++) {
if (i == length - 1)
total += 1.0 * dist[i] / speed;
else {
int curr = dist[i] / speed;
if (dist[i] % speed != 0)
curr++;
total += curr;
}
}
return total <= hour;
}
}
```