华为OD机试真题——组装最大可靠性设备（2025B卷：200分）Java/python/JavaScript/C++最佳实现

2025 B卷 200分 题型

本专栏内全部题目均提供Java、python、JavaScript、C++等多种语言的最佳实现方式；

并且每种语言均涵盖详细的问题分析、解题思路、代码实现、代码详解、3个测试用例以及综合分析；

本文收录于专栏：《2025华为OD真题目录+全流程解析+备考攻略+经验分享》

华为OD机试真题《组装最大可靠性设备》：

文章快捷目录

题目描述及说明

Java

python

JavaScript

C++

题目名称：组装最大可靠性设备

1. 知识点：二分查找、贪心算法、组合优化
2. 时间限制：1秒
3. 空间限制：256MB
4. 限定语言：不限

题目描述

一个设备由N种类型元器件组成（每种类型元器件只需要一个，类型编号为0~N-1）。每个元器件有两个属性：可靠性（reliability）和价格（price），其中可靠性越高的器件价格越贵。设备的整体可靠性由所有元器件中可靠性最低的一个决定。

给定预算S，需购买N种元器件（每种类型必须选一个），在不超过预算的情况下，求能组成的设备的最大可靠性。若预算无法购买N种器件，返回-1。

输入描述

• 第一行：预算S和元器件种类数N（空格分隔）。
• 第二行：元器件总数total。
• 后续total行：每行包含元器件的类型type、可靠性reliability、价格price（空格分隔）。

输出描述
符合预算的设备最大可靠性，无法满足则返回-1。

示例1
输入：

500 3  
6  
0 80 100  
0 90 200  
1 50 50  
1 70 210  
2 50 100  
2 60 150  

输出：

60  

说明：选择类型0的第一个（可靠性80）、类型1的第二个（可靠性70）、类型2的第二个（可靠性60），总成本100+210+150=460≤500，设备可靠性为min(80,70,60)=60。

示例2
输入：

100 1  
1  
0 90 200  

输出：

-1  

说明：仅需1个元件但价格超预算。

补充说明

• 0 ≤ S, price ≤ 10,000,000；0 ≤ N ≤ 100；0 ≤ total ≤ 10,000；0 < reliability ≤ 100,000。

Java

问题分析

我们需要在预算内为每种类型的元器件选择一个，使得设备的可靠性（所有元器件可靠性的最小值）最大化。设备可靠性由最低可靠性的元器件决定，因此我们需要在满足预算约束下最大化这个最小值。

解题思路

1. 数据结构设计：

   • 使用Component类存储元器件的可靠性和价格
   • 为每种类型维护元器件列表

2. 预处理：

   • 对每种类型的元器件按可靠性升序排序
   • 计算每种类型的后缀最小值数组（从后往前计算最小价格）

3. 二分查找：

   • 下界：1（最小可靠性）
   • 上界：所有类型最大可靠性的最小值
   • 对每个候选可靠性mid，检查是否存在满足条件的元器件组合

4. 可行性检查：

   • 对每种类型，二分查找第一个可靠性≥mid的元器件
   • 使用后缀最小值数组获取满足条件的最低价格
   • 计算总价格是否在预算内

代码实现

import java.util.*;

public class Main {
   
    static class Component {
   
        int reliability;
        long price;
        
        public Component(int reliability, long price) {
   
            this.reliability = reliability;
            this.price = price;
        }
    }

    public static void main(String[] args) {
   
        Scanner sc = new Scanner(System.in);
        // 读取预算和元器件类型数
        long S = sc.nextLong();
        int N = sc.nextInt();
        int total = sc.nextInt();
        
        // 处理N=0的特殊情况
        if (N == 0) {
   
            System.out.println(0);
            return;
        }
        
        // 初始化每种类型的元器件列表
        List<List<Component>> componentsByType = new ArrayList<>();
        for (int i = 0; i < N; i++) {
   
            componentsByType.add(new ArrayList<>());
        }
        
        // 读取所有元器件
        for (int i = 0; i < total; i++) {
   
            int type = sc.nextInt();
            int reliability = sc.nextInt();
            long price = sc.nextLong();
            // 将元器件添加到对应类型的列表
            if (type >= 0 && type < N) {
   
                componentsByType.get(type).add(new Component(reliability, price));
            }
        }
        
        // 检查每种类型是否有元器件
        for (int i = 0; i < N; i++) {
   
            if (componentsByType.get(i).isEmpty()) {
   
                System.out.println(-1);
                return;
            }
        }
        
        // 存储排序后的元器件列表
        List<List<Component>> sortedComponents = new ArrayList<>();
        // 存储每种类型的后缀最小值数组
        List<long[]> minPriceSuffix = new ArrayList<>();
        // 计算上界（所有类型最大可靠性的最小值）
        long high = Long.MAX_VALUE;
        
        // 处理每种类型的元器件
        for (int i = 0; i < N; i++) {
   
            List<Component> list = componentsByType.get(i);
            // 按可靠性升序排序
            Collections.sort(list, (a, b) -> {
   
                if (a.reliability != b.reliability) {
   
                    return Integer.compare(a.reliability, b.reliability);
                }
                return Long.compare(a.price, b.price);
            });
            sortedComponents.add(list);
            
            // 更新上界
            int lastIdx = list.size() - 1;
            high = Math.min(high, list.get(lastIdx).reliability);
            
            // 计算后缀最小值数组
            long[] suffixMin = new long[list.size()];
            suffixMin[list.size() - 1] = list.get(list.size() - 1).price;
            for (int j = list.size() - 2; j >= 0; j--) {
   
                suffixMin[j] = Math.min(list.get(j).price, suffixMin[j + 1]);
            }
            minPriceSuffix.add(suffixMin);
        }
        
        long low = 1; // 可靠性最小值为1
        long ans = -1; // 初始答案
        
        // 二分查找最大可靠性
        while (low <= high) {
   
            long mid = (low + high) / 2;
            long totalCost = 0;
            boolean valid = true;
            
            // 检查每种类型
            for (int i = 0; i < N; i++) {
   
                List<Component> list = sortedComponents.get(i);
                // 二分查找第一个可靠性≥mid的元器件
                int pos = firstGreaterEqual(list, mid);
                
                if (pos == list.size()) {
   
                    valid = false; // 没有满足条件的元器件
                    break;
                }
                
                // 累加最低价格
                totalCost += minPriceSuffix.get