运输时间 - 华为OD统一考试（C卷）

OD统一考试（C卷）

分值： 200分

题解： Java / Python / C++

题目描述

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

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

注意：

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

输入描述

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

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

• 1 ≤ M ≤ 20
• 1 ≤ N ≤ 400
• 0 < S < 30

输出描述

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

示例1

输入：
2 11
3
2

输出：
5.5

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

题解

该问题涉及到车辆在单行道上行驶，不能超车，每辆车按照固定间隔出发，且速度较快的车追上前车后只能以前车的速度行驶。我们需要计算最后一辆车到达目的地所需的时间。

思路：

1. 读取输入的车辆数 M 和到终点的距离 N。
2. 使用一个循环读取每辆车的速度，并计算该车到达目的地的时间。
3. 在计算过程中，记录最后一辆车到达目的地最晚的时间。
4. 最后，输出最后一辆车到达目的地花费的时间。

该问题的关键点是在计算每辆车到达目的地的时间时，要考虑可能的阻塞情况，即后面的车可能会追上前车。

因此，要取每辆车到达时间的最大值。最后输出最后一辆车到达目的地花费的时间即可。

Java

import java.util.Scanner;

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

        int M = scanner.nextInt();
        int N = scanner.nextInt();

        // 最后一辆车到达目的地最晚的时间
        double maxCostTime = 0;

        for (int waitTime = 0; waitTime < M; waitTime++) {
            int speed = scanner.nextInt();
            // 没有阻塞时，当前车到达目的地的时间是： N / speed + waitTime
            // 由于可能阻塞所以耗时只能取最大值
            maxCostTime = Math.max(maxCostTime, 1.0 * N / speed + waitTime);
        }

        // 需要排队，所以最后一辆成肯定最后到达终点
        // 因此， 最后一辆车到达目的地花费的时间 = maxCostTime - waitTime
        System.out.println(maxCostTime - M + 1);
    }
}

Python

M, N = map(int, input().split())

# 最后一辆车到达目的地最晚的时间
max_cost_time = 0
for wait_time in range(M):
    speed = int(input())
    # 没有阻塞时，当前车到达目的地的时间是：  N / speed + wait_time
    # 由于可能阻塞所以耗时只能取最大值
    max_cost_time = max(max_cost_time, N / speed + wait_time)

# 需要排队，所以最后一辆成肯定最后到达终点
# 因此， 最后一辆车到达目的地花费的时间 = max_cost_time - wait_time
print(max_cost_time - M + 1)

C++

#include <iostream>
#include <algorithm>

using namespace std;

int main() {
    // 读取输入
    int M, N;
    cin >> M >> N;

    // 最后一辆车到达目的地最晚的时间
    double maxCostTime = 0;

    for (int waitTime = 0; waitTime < M; waitTime++) {
        int speed;
        cin >> speed;
        // 没有阻塞时，当前车到达目的地的时间是： N / speed + waitTime
        // 由于可能阻塞所以耗时只能取最大值
        maxCostTime = max(maxCostTime, 1.0 * N / speed + waitTime);
    }

    // 需要排队，所以最后一辆成肯定最后到达终点
    // 因此， 最后一辆车到达目的地花费的时间 = maxCostTime - waitTime
    cout << maxCostTime - M + 1 << endl;

    return 0;
}

🙏整理题解不易， 如果有帮助到您，请给点个赞 ‍❤️‍ 和收藏 ⭐，让更多的人看到。🙏🙏🙏