【华为OD机试真题】C卷-虚拟理财游戏（JAVA）

一、题目描述

【华为OD机试真题】C卷-虚拟理财游戏（JAVA）

题目描述：

在一款虚拟游戏中生活，你必须进行投资以增强在虚拟游戏中的资产以免被淘汰出局。
现有一家Bank，它提供有若干理财产品 m 个，风险及投资回报不同，你有 N（元）进行投资，能接收的总风险值为X。
你要在可接受范围内选择最优的投资方式获得最大回报。

备注：
在虚拟游戏中，每项投资风险值相加为总风险值；
在虚拟游戏中，最多只能投资2个理财产品；
在虚拟游戏中，最小单位为整数，不能拆分为小数；
投资额*回报率=投资回报

二、输入输出

输入描述：
第一行：
产品数（取值范围[1,20]）
总投资额（整数，取值范围[1, 10000]）
可接受的总风险（整数，取值范围[1,200]）
第二行：产品投资回报率序列，输入为整数，取值范围[1,60]
第三行：产品风险值序列，输入为整数，取值范围[1, 100]
第四行：最大投资额度序列，输入为整数，取值范围[1, 10000]

输出描述：
每个产品的投资额序列

三、参考示例

用例
输入：
5 100 10
10 20 30 40 50
3 4 5 6 10
20 30 20 40 30
输出：
0 30 0 40 0
说明：
投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10

四、解题思路

1. 获取输入参数。
2. 遍历产品，选择最佳投资方案。
3. 根据风险和背景收益计算投资收益，选择最优方案。
4. 输出最终选择的投资方案。

五、参考代码

/*
 * @Author: mgc
 * @Date: 2024-02-02 17:47:00
 * @LastEditors: Do not edit
 * @LastEditTime: 2024-02-02 17:48:55
 */

// import java.util.*;
// import java.util.HashMap;
// import java.util.Scanner;
// import java.util.regex.Matcher;
// import java.util.stream.Stream;
// import java.util.regex.Pattern;
// import java.util.stream.Collectors;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;
import java.util.StringJoiner;

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

        // 读取输入参数
        int[] inputParams = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        int productCount = inputParams[0]; // 产品数
        int totalInvestment = inputParams[1]; // 总投资
        int totalRisk = inputParams[2]; // 总风险

        int[] backReturns = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        int[] risks = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        int[] investments = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

        int maxInvestBack = 0;
        int maxInvestBackRisk = Integer.MAX_VALUE;
        HashMap<Integer, Integer> selection = new HashMap<>();

        // 选择最佳投资方案
        for (int i = 0; i < productCount; i++) {
            if (risks[i] <= totalRisk) {
                int investI = Math.min(investments[i], totalInvestment);
                int investBack = investI * backReturns[i];

                if (investBack > maxInvestBack || (investBack == maxInvestBack && risks[i] < maxInvestBackRisk)) {
                    maxInvestBack = investBack;
                    maxInvestBackRisk = risks[i];
                    selection.clear();
                    selection.put(i, investI);
                }
            } else {
                continue;
            }

            for (int j = i + 1; j < productCount; j++) {
                if (risks[i] + risks[j] <= totalRisk) {
                    int investI;
                    int investJ;

                    if (backReturns[i] > backReturns[j]) {
                        investI = Math.min(totalInvestment, investments[i]);
                        investJ = Math.min(totalInvestment - investI, investments[j]);
                    } else if (backReturns[i] < backReturns[j]) {
                        investJ = Math.min(totalInvestment, investments[j]);
                        investI = Math.min(totalInvestment - investJ, investments[i]);
                    } else if (risks[i] > risks[j]) {
                        investJ = Math.min(totalInvestment, investments[j]);
                        investI = Math.min(totalInvestment - investJ, investments[i]);
                    } else {
                        investI = Math.min(totalInvestment, investments[i]);
                        investJ = Math.min(totalInvestment - investI, investments[j]);
                    }

                    int investBack = investI * backReturns[i] + investJ * backReturns[j];
                    int investBackRisk = risks[i] + risks[j];

                    if (investBack > maxInvestBack || (investBack == maxInvestBack && investBackRisk < maxInvestBackRisk)) {
                        maxInvestBack = investBack;
                        maxInvestBackRisk = investBackRisk;
                        selection.clear();
                        if (investI > 0) selection.put(i, investI);
                        if (investJ > 0) selection.put(j, investJ);
                    }
                }
            }
        }

        // 输出最终选择的投资方案
        StringJoiner result = new StringJoiner(" ");
        for (int i = 0; i < productCount; i++) {
            if (selection.containsKey(i)) {
                result.add(selection.get(i) + "");
            } else {
                result.add("0");
            }
        }

        System.out.println(result);
    }
}

六、华为OD机试真题汇总目录

    【华为OD机试】真题汇总A+B+C+D券（Python实现）

    【华为OD机试】真题汇总A+B+C+D卷（JAVA实现）

    【华为OD机试】真题汇总A+B+C+D卷（C++实现）