# 欢迎来到「欧弟算法 - 华为OD全攻略」,收录华为OD题库、面试指南、八股文与学员案例！
# 地址：https://www.odalgo.com
# 华为OD机试刷题网站：https://www.algomooc.com
# 添加微信 278166530 获取华为 OD 笔试真题题库和视频


# 导入向上取整函数ceil，用于后续的计算
from math import ceil


nums = list(map(int, input().split()))
h = int(input())


# 计算在速度k的条件下，所花费的时间h的函数
def cal_hour_used(nums, k):
    return sum(ceil(p / k) for p in nums)


# 二分查找求解问题的函数
def minEatingSpeed(nums, h):
    # 左闭右开
    left, right = 1, max(nums) + 1
    while left < right:
        mid = (left + right) // 2
        # 花费时间太少，速度偏大，速度还可以减小，
        # 搜索区间向左折半，right可以向左移动
        if cal_hour_used(nums, mid) <= h:
            right = mid
        else:
            left = mid + 1
    return left


# 如果nums的长度已经大于h，一定无法在h小时内吃完所有蟠桃
# 直接输出0
if len(nums) > h:
    print(0)
# 否则进行二分，输出答案
else:
    print(minEatingSpeed(nums, h))

Java

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] numsStr = scanner.nextLine().split(" ");
        int[] nums = new int[numsStr.length];
        for (int i = 0; i < numsStr.length; i++) {
            nums[i] = Integer.parseInt(numsStr[i]);
        }
        int h = scanner.nextInt();

        int left = 1;
        int right = getMax(nums) + 1;

        while (left < right) {
            int mid = left + (right - left) / 2;
            if (calHourUsed(nums, mid) <= h) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }

        if (nums.length > h) {
            System.out.println(0);
        } else {
            System.out.println(left);
        }
    }

    public static int calHourUsed(int[] nums, int k) {
        int hour = 0;
        for (int p : nums) {
            hour += Math.ceil((double) p / k);
        }
        return hour;
    }

    public static int getMax(int[] nums) {
        int max = Integer.MIN_VALUE;
        for (int num : nums) {
            max = Math.max(max, num);
        }
        return max;
    }
}

C++

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <climits>
using namespace std;

int calHourUsed(vector<int>& nums, int k) {
    int hour = 0;
    for (int p : nums) {
        hour += ceil((double) p / k);
    }
    return hour;
}

int getMax(vector<int>& nums) {
    int max = INT_MIN;
    for (int num : nums) {
        max = std::max(max, num);
    }
    return max;
}

int main() {
    string input;
    getline(cin, input);
    string input2;
    getline(cin, input2);

    vector<int> nums;
    size_t pos = 0;
    while ((pos = input.find(' ')) != string::npos) {
        nums.push_back(stoi(input.substr(0, pos)));
        input.erase(0, pos + 1);
    }
    nums.push_back(stoi(input));

    int h = stoi(input2);

    int left = 1;
    int right = getMax(nums) + 1;

    while (left < right) {
        int mid = left + (right - left) / 2;
        if (calHourUsed(nums, mid) <= h) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }

    if (nums.size() > h) {
        cout << 0 << endl;
    } else {
        cout << left << endl;
    }

    return 0;
}

C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <limits.h>

// 计算在给定速度 k 下完成所有任务所需的小时数
int calHourUsed(int* nums, int len, int k) {
    int hour = 0;
    for (int i = 0; i < len; i++) {
        hour += (int)ceil((double)nums[i] / k);
    }
    return hour;
}

// 获取数组中的最大值
int getMax(int* nums, int len) {
    int max = INT_MIN;
    for (int i = 0; i < len; i++) {
        if (nums[i] > max) {
            max = nums[i];
        }
    }
    return max;
}

// 主函数
int main() {
    char line1[100000], line2[1000];
    fgets(line1, sizeof(line1), stdin);  // 读取第一行（任务数组）
    fgets(line2, sizeof(line2), stdin);  // 读取第二行（总时间 h）

    // 解析 line1 为整数数组
    int nums[10000];  // 假设最多不超过1000个任务
    int count = 0;

    char* token = strtok(line1, " \n");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, " \n");
    }

    // 解析 h
    int h = atoi(line2);

    int left = 1;
    int right = getMax(nums, count) + 1;

    // 二分搜索最小可行速度
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (calHourUsed(nums, count, mid) <= h) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }

    // 如果任务数大于小时数，必定无法完成
    if (count > h) {
        printf("0\n");
    } else {
        printf("%d\n", left);
    }

    return 0;
}

Node JavaScript

const readline = require("readline");

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

let inputLines = [];

rl.on("line", function (line) {
    inputLines.push(line.trim());
    if (inputLines.length === 2) {
        const nums = inputLines[0].split(" ").map(Number);
        const h = parseInt(inputLines[1]);

        // 如果元素个数比h还多，必定无法完成
        if (nums.length > h) {
            console.log(0);
            rl.close();
            return;
        }

        let left = 1;
        let right = Math.max(...nums) + 1;

        while (left < right) {
            let mid = Math.floor(left + (right - left) / 2);
            if (calHourUsed(nums, mid) <= h) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }

        console.log(left);
        rl.close();
    }
});

// 计算以速度k完成所有任务所需的小时数
function calHourUsed(nums, k) {
    let hour = 0;
    for (let p of nums) {
        hour += Math.ceil(p / k);
    }
    return hour;
}

时空复杂度

时间复杂度：O(NlogN)。其中N为nums数组长度。
空间复杂度：O(1)。