返回目录

题目描述

M（1<=M<=20）辆车需要在一条不能超车的单行道到达终点，起点到终点的距离为N（1<=N<=400）。速度快的车追上前车后，只能以前车的速度继续行驶。求最后一车辆到达目的地花费的时间。

注：每辆车固定间隔一小时出发，比如第一辆车0时出发，第二辆车1时出发，以此类推

输入描述

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

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

输出描述

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

示例：

Python算法源码

# 获取车辆数M和终点距离N
M, N = map(int, input().split())

# 获取每辆车的速度并存储在列表speeds中
speeds = list(map(int, input().split()))

# 初始化arrivalTimes列表，其中存储第一辆车到达目的地的时间
arrival_times = [N / speeds[0]]

# 对于剩余的车辆，循环计算每辆车到达目的地的时间
# 如果当前车辆比前一辆车更晚到达或与前一辆车同时到达，则更新时间并添加到arrival_times
for index in range(1, M):
    # 计算第index辆车单独行驶到目的地的时间，即终点距离N除以车速speeds[index]
    # 由于车辆是依次出发的，所以还需要加上车辆的出发延迟时间index
    estimated_time = N / speeds[index] + index

    # 比较当前车辆计算出的到达时间estimated_time和前一辆车的到达时间arrival_times[index - 1]
    # 使用max函数确保当前车辆的到达时间不会早于前一辆车
    adjusted_time = max(estimated_time, arrival_times[index - 1])
    arrival_times.append(adjusted_time)

# 输出最后一辆车到达目的地的时间，但减去M再加1（这是因为车辆从0开始计数，而时间是从1开始计数）
print('{:.1f}'.format(arrival_times[-1] - M + 1))

C语言算法源码

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 获取车辆数M和终点距离N
    int M, N;
    scanf("%d %d", &M, &N);

    // 获取每辆车的速度并存储在数组speeds中
    int *speeds = (int *)malloc(M * sizeof(int));
    for (int index = 0; index < M; index++) {
        scanf("%d", &speeds[index]);
    }

    // 初始化arrivalTimes数组，其中存储第一辆车到达目的地的时间
    double *arrivalTimes = (double *)malloc(M * sizeof(double));
    arrivalTimes[0] = (double)N / speeds[0];

    // 对于剩余的车辆，循环计算每辆车到达目的地的时间
    // 如果当前车辆比前一辆车更晚到达或与前一辆车同时到达，则更新时间并添加到arrivalTimes
    for (int index = 1; index < M; index++) {
        // 计算第index辆车单独行驶到目的地的时间，即终点距离N除以车速speeds[index]
        // 由于车辆是依次出发的，所以还需要加上车辆的出发延迟时间index
        double estimatedTime = (double)N / speeds[index] + index;

        // 比较当前车辆计算出的到达时间estimatedTime和前一辆车的到达时间arrivalTimes[index - 1]
        // 使用max函数确保当前车辆的到达时间不会早于前一辆车
        double adjustedTime = (estimatedTime > arrivalTimes[index - 1]) ? estimatedTime : arrivalTimes[index - 1];
        arrivalTimes[index] = adjustedTime;
    }

    // 输出最后一辆车到达目的地的时间，但减去M再加1（这是因为车辆从0开始计数，而时间是从1开始计数）
    printf("%.1f\n", arrivalTimes[M - 1] - M + 1);

    free(speeds);
    free(arrivalTimes);

    return 0;
}

Java算法源码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 创建Scanner对象用于输入
        Scanner scanner = new Scanner(System.in);

        // 获取车辆数M和终点距离N
        int M = scanner.nextInt();
        int N = scanner.nextInt();

        // 获取每辆车的速度并存储在数组speeds中
        int[] speeds = new int[M];
        for (int index = 0; index < M; index++) {
            speeds[index] = scanner.nextInt();
        }

        // 初始化arrivalTimes数组，其中存储第一辆车到达目的地的时间
        double[] arrivalTimes = new double[M];
        arrivalTimes[0] = (double) N / speeds[0];

        // 对于剩余的车辆，循环计算每辆车到达目的地的时间
        // 如果当前车辆比前一辆车更晚到达或与前一辆车同时到达，则更新时间并添加到arrivalTimes
        for (int index = 1; index < M; index++) {
            // 计算第index辆车单独行驶到目的地的时间，即终点距离N除以车速speeds[index]
            // 由于车辆是依次出发的，所以还需要加上车辆的出发延迟时间index
            double estimatedTime = (double) N / speeds[index] + index;

            // 比较当前车辆计算出的到达时间estimatedTime和前一辆车的到达时间arrivalTimes[index - 1]
            // 使用Math.max函数确保当前车辆的到达时间不会早于前一辆车
            double adjustedTime = Math.max(estimatedTime, arrivalTimes[index - 1]);
            arrivalTimes[index] = adjustedTime;
        }

        // 输出最后一辆车到达目的地的时间，但减去M再加1（这是因为车辆从0开始计数，而时间是从1开始计数）
        System.out.printf("%.1f\n", arrivalTimes[M - 1] - M + 1);

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