当前位置：首页 > article >正文

机器人搬砖 - 华为OD统一考试

article 2024/9/25 23:21:58

OD统一考试（C卷）

分值： 100分

题解： Java / Python / C++

alt

题目描述

机器人搬砖，一共有N堆砖存放在N个不同的仓库中，第 i 堆中有 bricks[i] 块砖头，要求在8小时内搬完。

机器人每小时能搬砖的数量取决于有多少能量格，机器人一个小时中只能在一仓库中搬砖，机器人的能量格每小时补充一次且能量格只在这一个小时有效，为使得机器人损耗最小化，应尽量减小每次补充的能量格数。

为了保障在8小时内能完成砖任务，请计算每小时始机器人充能的最小能量格数。

备注:

1、无需考虑机器人补充能量的耗时

2、无需考虑机器人搬砖的耗时

3、机器人每小时补充能量格只在这一个小时中有效

输入描述

程序有输入为“30 12 25 8 19”一个整数数组，数组中的每个数字代表第i堆砖的个数，每堆砖的个数不超过100

输出描述

输出在8小时内完成搬砖任务，机器人每小时最少需要充多少个能量格；

如果8个小时内无法完成任务，则输出“-1”；

示例1

输入：
30 12 25 8 19

输出：
15

示例2

输入：
10 12 25 8 19 8 6 4 17 19 20 30

输出：
-1

说明：
砖的堆数为12堆存放在12个仓库中，机器人一个小时内只能在一个仓库搬砖，不可能完成任务

题解

解题思路：

题目要求机器人在8小时内搬完N堆砖，每小时搬砖的数量取决于机器人每小时充能的能量格数。
机器人每小时只能在一个仓库搬砖，因此仓库数不能超过8。
需要计算每小时机器人充能的最小能量格数，使得能够在8小时内完成搬砖任务。
使用二分查找的思想，通过不断调整充能的能量格数，找到一个最小的能量格数，使得在8小时内能够完成搬砖任务。
判断条件为每小时搬砖的天数是否小于等于8，若是则说明当前充能的能量格数足够，可以减小能量格数，否则需要增加充能的能量格数。

Java

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

        // 读取输入的砖块数
        int[] bricks = Arrays.stream(in.nextLine().split(" "))
                .mapToInt(Integer::parseInt).toArray();

        // 机器人一个小时内只能在一个仓库搬砖, 因此仓库数不能超过 8
        if (bricks.length > 8) {
            System.out.println(-1);
        } else {
            int l = -1, r = Arrays.stream(bricks).max().getAsInt();
            while (l + 1 < r) {
                int m = (l + r) >>> 1;
                if (check(bricks, m)) {
                    r = m;
                } else {
                    l = m;
                }
            }

            System.out.println(r);
        }
    }

    // 判断机器人每小时充 power 能量，能否在 8 个小时内搬完
    private static boolean check(int[] bricks, int power) {
        int days = 0;
        for (int brick : bricks) {
            days += (brick + power - 1) / power;
        }

        return days <= 8;
    }
}

Python

from typing import List


def check(bricks: List[int], power: int) -> bool:
    """判断机器人每小时充 power 能量，能否在 8 个小时内搬完"""
    days = 0
    for brick in bricks:
        days += (brick + power - 1) // power

    return days <= 8


if __name__ == '__main__':
    bricks = list(map(int, input().split()))
    if len(bricks) > 8:  # 机器人一个小时内只能在一个仓库搬砖,因此仓库数不能超过 8
        print(-1)
    else:
        l, r = -1, max(bricks)
        while l + 1 < r:
            m = (l + r) >> 1
            if check(bricks, m):
                r = m
            else:
                l = m
        print(r)

C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// 判断机器人每小时充 power 能量，能否在 8 个小时内搬完
bool check(const vector<int>& bricks, int power) {
    int days = 0;
    for (int brick : bricks) {
        days += (brick + power - 1) / power;
    }

    return days <= 8;
}

int main() {
    vector<int> bricks;
    int brick;
    while (cin >> brick) {
        bricks.push_back(brick);
    }

    // 机器人一个小时内只能在一个仓库搬砖, 因此仓库数不能超过 8
    if (bricks.size() > 8) {
        cout << -1 << endl;
    } else {
        int l = -1, r = *max_element(bricks.begin(), bricks.end());
        while (l + 1 < r) {
            int m = (l + r) / 2;
            if (check(bricks, m)) {
                r = m;
            } else {
                l = m;
            }
        }

        cout << r << endl;
    }

    return 0;
}