2024年华为OD机试真题-执行时长

华为OD机试真题-执行时长-2024年OD统一考试（D卷）

题目描述：

为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务，假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成

输入描述：

第一个参数为GPU一次最多执行的任务个数，取值范围[1, 10000]

第二个参数为任务数组长度，取值范围[1, 10000]

第三个参数为任务数组，数字范围[1, 10000]

输出描述：

执行完所有任务最少需要多少秒

补充说明：

示例1

输入：

3

5

1 2 3 4 5

输出：

6

说明：

一次最多执行3个任务，最少耗时6s

示例2

输入：

4

5

5 4 1 1 1

输出：

5

说明：

一次最多执行4个任务，最少耗时5s

解题思路：

（1）我们需要逐秒地处理任务数组中的任务，并跟踪未完成的任务数。

（2）如果在某一秒内的总任务数（包括未完成任务）超过GPU一次能处理的最大任务数，我们需要增加1秒的时间，并减少处理的任务数。

（3）如果总任务数不超过最大任务数，我们也需要增加1秒的时间，但所有任务都能在这一秒内完成。

（4）在任务数组处理完后，如果还有未完成的任务，计算完成剩余任务所需的时间，并加到总时间上。

c++解法：

#include <iostream>
using namespace std;
 
int main() {
    int n, size;
    cin >> n >> size;
    
    int a = 0;
    int ans = size;
 
    int tmp;
    int i = 0;
    while(i < size)
    {
        cin >> tmp;
        a += tmp;
        if(a < n) a = 0;
        else a -= n;
 
        i++;
    }
 
    ans += a/n;
 
    if(a%n != 0) ans ++;
 
    cout<<ans;
    return 0;
}

Java解法：

import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
 
        // 输入GPU一次最多执行的任务个数
        int maxTasks = scanner.nextInt();
        // 输入任务数组的长度
        int numTasks = scanner.nextInt();
        // 输入任务数组
        int[] tasks = new int[numTasks];
        for (int i = 0; i < numTasks; i++) {
            tasks[i] = scanner.nextInt();
        }
 
        // 调用计算最少时间的函数
        int result = calculateMinTime(maxTasks, tasks);
        System.out.println(result);
 
        scanner.close();
    }
 
    public static int calculateMinTime(int maxTasks, int[] tasks) {
        int time = 0;
        int remainingTasks = 0;
 
        for (int task : tasks) {
            remainingTasks += task; // 累加当前时刻新增的任务
 
            // 如果剩余任务超过了GPU一次能执行的任务数
            if (remainingTasks > maxTasks) {
                time += 1;
                remainingTasks -= maxTasks; // 执行maxTasks个任务
            } else {
                time += 1;
                remainingTasks = 0; // 执行所有剩余任务
            }
        }
 
        // 如果循环结束后还有未完成的任务
        if (remainingTasks > 0) {
            time += (remainingTasks + maxTasks - 1) / maxTasks; // 向上取整
        }
 
        return time;
    }
}

python解法：

def calculate_min_time(max_tasks, tasks):
    time = 0
    remaining_tasks = 0
 
    for task in tasks:
        remaining_tasks += task  # 累加当前时刻新增的任务
 
        # 如果剩余任务超过了GPU一次能执行的任务数
        if remaining_tasks > max_tasks:
            time += 1
            remaining_tasks -= max_tasks  # 执行maxTasks个任务
        else:
            time += 1
            remaining_tasks = 0  # 执行所有剩余任务
 
    # 如果循环结束后还有未完成的任务
    if remaining_tasks > 0:
        time += (remaining_tasks + max_tasks - 1) // max_tasks  # 向上取整
 
    return time
 
 
if __name__ == "__main__":
    # 输入GPU一次最多执行的任务个数
    max_tasks = int(input().strip())
    # 输入任务数组的长度
    num_tasks = int(input().strip())
    # 输入任务数组
    tasks = list(map(int, input().strip().split()))
 
    # 调用计算最少时间的函数
    result = calculate_min_time(max_tasks, tasks)
    print(result)

欢迎交流指正~