思路：模拟

首先，对于第一辆车0，他的前面没有车，因此它到达终点的时间$t_0=\frac{n}{speed[0]}$

对于第二辆车1，他的前面有第一辆车0阻挡，因此他到达终点的时间需要分情况讨论

• 情况1：$speed[1]$较小，在车0到达终点之前追不上车0，因此，它到达终点的时间$t_1=\frac{n}{speed[1]}$
• 情况2：$speed[1]较大$，可以在车0到达重点之前追上，因此它到达终点的时间$t_1=t_0-1$（比$t_0$晚出发一小时)

因此根据上述情况分类讨论模拟即可，具体可以参考下面代码。

JavaScript

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

let m, n, ans, w;

// 用于记录已经读取了多少行
let lineCount = 0;

rl.on('line', (line) => {
  if (lineCount === 0) {
    // 第一行输入，解析为 m 和 n
    [m, n] = line.split(' ').map(Number);
    ans = 0;
    w = new Array(m);
  } else {
    // 接下来的 m 行输入，分别是速度列表 w 的元素
    w[lineCount - 1] = parseInt(line);

    // 当读取完 m 行后，计算最大花费时间并输出结果
    if (lineCount === m) {
      for (let i = 0; i < m; i++) {
        // 计算按照当前速度行驶到达终点所需要的时间
        const t = n / w[i];
        
        // 如果是第一个人，或者追不上前面一个人，更新最大花费时间 ans
        if (i === 0 || t >= ans - 1) {
          ans = t;
        } else if (t < ans - 1) {
          // 如果追上了前面一个人，更新最大花费时间 ans 为当前时间减一
          ans = ans - 1;
        }
      }

      // 输出结果
      console.log(ans);

      // 关闭 rl
      rl.close();
    }
  }

  // 更新行数
  lineCount++;
});

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取 m 和 n
        int m = scanner.nextInt();
        int n = scanner.nextInt();

        // 初始化最大花费时间 ans 为 0
        double ans = 0;

        // 创建数组 w 用于存储每个人的速度
        int[] w = new int[m];

        // 读取数组 w 的值，即每个人的速度
        for (int i = 0; i < m; i++) {
            w[i] = scanner.nextInt();
        }

        // 遍历数组计算最大花费时间 ans
        for (int i = 0; i < m; i++) {
            // 计算按照当前速度行驶到达终点所需要的时间
            double t = (double) n / w[i];
            
            // 如果是第一个人，或者追不上前面一个人，更新最大花费时间 ans
            if (i == 0 || t >= ans - 1) {
                ans = t;
            } else {
                // 如果追上了前面一个人，更新最大花费时间 ans 为当前时间减一
                ans = ans - 1;
            }
        }

        // 输出结果
        System.out.println(ans);

        // 关闭 Scanner
        scanner.close();
    }
}

Python

m,n=map(int,input().split())
ans=0  #最大花费时间
w=[0]*m
for i in range(m):
    w[i]=int(input())
for i in range(m):
    t=n/w[i]  #如果一直按照当前速度行驶到达终点所需要的时间
    if i==0 or t>=ans-1:  #第一个人或者追不上前面一个人
        ans=t
    elif t<ans-1: #追上了前面一个人
        ans=ans-1
print(ans)

C++

#include <iostream>
#include <iomanip> // Include the iomanip header for fixed and setprecision
#include <vector>

using namespace std;

int main() {
    // 读取 m 和 n
    int m, n;
    cin >> m >> n;
    // 初始化最大花费时间 ans 为 0
    double ans = 0.0;
    // 创建数组 w 用于存储每个人的速度
    vector<double> w(m);
    // 读取数组 w 的值，即每个人的速度
    for (int i = 0; i < m; i++) {
        cin >> w[i];
    }
    // 遍历数组计算最大花费时间 ans
    for (int i = 0; i < m; i++) {
        // 计算按照当前速度行驶到达终点所需要的时间
        double t = 1.0 * n / w[i];
        // 如果是第一个人，或者追不上前面一个人，更新最大花费时间 ans
        if (i == 0 || t - ans + 1.0 > 1e-4) {
            ans = t;
        } else {
            // 如果追上了前面一个人，更新最大花费时间 ans 为当前时间减一
            ans = ans - 1.0;
        }
    }

    cout << fixed << setprecision(1) << ans << endl;

    return 0;
}

题目描述

$M$ 辆车需要在一条不能超车的单行道到达终点，起点到终点的距离为 $N$ 。

速度快的车追上前车后，只能以前车的速度继续行驶，求最后一车辆到达目的地花费的时间。

注意：

每辆车固定间隔 $1$ 小时出发，比如第一辆车 $0$ 时出发，第二辆车 $1$ 时出发，依次类推。

输入描述

第一行两个数字： $M$ 、 $N$ ，分别代表车辆数和到终点的距离，以空格分隔。

接下来 $M$ 行，每行 $1$ 个数字 $S$ ,代表每辆车的速度。

• $1\le M \le 20$
• $1\le N \le 400$
• $0\lt S \lt 30$

输出描述

最后一辆车到达目的地花费的时间。

示例1

输入

2 11
3
2

输出

5.5

说明：

$2$ 辆车，距离 $11$ ， $0$ 时出发的车速度快， $1$ 时出发的车，达到目的地花费 $5.5$ 。