返回目录

题目描述

为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。

假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。

输入描述

• 第一个参数为GPU一次最多执行的任务个数，取值范围[1, 10000]
• 第二个参数为任务数组长度，取值范围[1, 10000]
• 第三个参数为任务数组，数字范围[1, 10000]

输出描述

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

示例：

题目解析

题干中有一个段话很关键："数组元素表示在这1秒内新增的任务个数且每秒都有新增任务"，也就是说，数组中的任务个数不是一次性push完的，而是每过1s才push一次，而这刚好和GPU单次执行时间1s相温吻合。

Python算法源码

def get_result(max_count, tasks):
    time = 0  # 时间变量，用于记录总共需要的时间
    remain = 0  # 剩余任务时间，用于记录上一轮任务处理完后剩余的时间

    for task in tasks:
        if task + remain > max_count:
            # 如果当前任务执行需要的时间加上剩余时间超过了最大处理量
            remain = task + remain - max_count  # 计算剩余时间
        else:
            remain = 0  # 如果可以执行当前任务，则剩余时间为 0
        time += 1  # 执行任务，总时间加一

    # 处理完所有任务后，如果还有剩余时间，需要再加一轮
    while remain > 0:
        remain -= max_count  # 扣除最大处理量
        time += 1  # 总时间加一

    return time


if __name__ == "__main__":
    max_count = int(input())  # 输入最大处理量
    n = int(input())  # 输入任务数量
    tasks = list(map(int, input().split()))  # 输入任务时间列表

    print(get_result(max_count, tasks))  # 输出最小时间

C算法源码

#include <stdio.h>

int get_result(int max_count, int *tasks, int n) {
    int time = 0; // 时间变量，用于记录总共需要的时间
    int remain = 0; // 剩余任务时间，用于记录上一轮任务处理完后剩余的时间

    for (int i = 0; i < n; i++) {
        int task = tasks[i];
        if (task + remain > max_count) {
            // 如果当前任务执行需要的时间加上剩余时间超过了最大处理量
            remain = task + remain - max_count; // 计算剩余时间
        } else {
            remain = 0; // 如果可以执行当前任务，则剩余时间为 0
        }
        time++; // 执行任务，总时间加一
    }

    // 处理完所有任务后，如果还有剩余时间，需要再加一轮
    while (remain > 0) {
        remain -= max_count; // 扣除最大处理量
        time++; // 总时间加一
    }

    return time;
}

int main() {
    int max_count, n;
    scanf("%d", &max_count); // 输入最大处理量
    scanf("%d", &n); // 输入任务数量
    int tasks[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &tasks[i]); // 输入任务时间列表
    }

    printf("%d\n", get_result(max_count, tasks, n)); // 输出最小时间

    return 0;
}

Java算法源码

import java.util.Scanner;

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

        int maxCount = scanner.nextInt(); // 输入最大处理量
        int n = scanner.nextInt(); // 输入任务数量
        int[] tasks = new int[n]; // 创建任务时间数组
        for (int i = 0; i < n; i++) {
            tasks[i] = scanner.nextInt(); // 输入任务时间列表
        }

        System.out.println(getResult(maxCount, tasks)); // 输出最小时间

        scanner.close(); // 关闭输入流
    }

    public static int getResult(int maxCount, int[] tasks) {
        int time = 0; // 时间变量，用于记录总共需要的时间
        int remain = 0; // 剩余任务时间，用于记录上一轮任务处理完后剩余的时间

        for (int task : tasks) {
            if (task + remain > maxCount) {
                remain = task + remain - maxCount; // 计算剩余时间
            } else {
                remain = 0; // 如果可以执行当前任务，则剩余时间为 0
            }
            time++; // 执行任务，总时间加一
        }

        // 处理完所有任务后，如果还有剩余时间，需要再加一轮
        while (remain > 0) {
            remain -= maxCount; // 扣除最大处理量
            time++; // 总时间加一
        }

        return time; // 返回最小时间
    }
}