华为OD- 贪心的商人-2024年OD（E卷）

题目描述

商人经营一家店铺，有number种商品， 由于仓库限制每件商品的最大持有数量是item[index] 每种商品的价格是item-priceitem_index 通过对商品的买进和卖出获取利润 请给出商人在days天内能获取的最大的利润 注：同一件商品可以反复买进和卖出

输入描述

第一行输入商品的数量number，比如3 第二行输入商品售货天数 days，比如3 第三行输入仓库限制每件商品的最大持有数量是item[index]，比如4 5 6

后面继续输入number行days列，含义如下： 第一件商品每天的价格，比如1 2 3 第二件商品每天的价格，比如4 3 2 第三件商品每天的价格，比如1 5 3

输出描述

输出商人在这段时间内的最大利润。

用例

解题思路

1. 问题描述：

   • 给定一个商店内的商品种类数 number，每种商品的库存量 item，以及商品的每日价格 prices。
   • 需要计算通过每天买入和卖出商品所能获得的最大利润。

2. 解法：

   • 遍历每种商品，对于每种商品计算通过价格差产生的利润：
     • 如果某天的价格高于前一天，则可以通过在前一天买入，在当天卖出获利。
     • 利润计算公式：(当前价格 - 前一天价格) * 库存数量。
   • 累积每种商品的总利润得到最终答案。

3. 实现步骤：

   • 遍历商品种类。
   • 对于每种商品，从最后一天倒序遍历价格表。
   • 比较当前价格和前一天价格，计算利润并累积。
   • 返回累积利润的总和。

python源码：

# 读取输入
number = int(input())  # 商品种类数
days = int(input())  # 天数
item = list(map(int, input().split()))  # 每种商品的库存量
prices = [list(map(int, input().split())) for i in range(number)]  # 每种商品每日价格

# 定义计算最大利润的函数
def getResult(number, days, item, prices):
    ans = 0  # 初始化总利润
    for i in range(number):  # 遍历每种商品
        total_profit = 0  # 当前商品的总利润
        for j in range(days - 1, 0, -1):  # 从最后一天倒序遍历到第一天
            # 如果当天价格比前一天高，则可以获利
            if prices[i][j] > prices[i][j - 1]:
                # 计算利润：价格差 * 库存量
                total_profit += (prices[i][j] - prices[i][j - 1]) * item[i]
        ans += total_profit  # 累积当前商品的利润到总利润中
    return ans  # 返回总利润

# 调用函数并输出结果
print(getResult(number, days, item, prices))

 java源码：

import java.util.Scanner;

public class Main {
    // 类成员变量，存储商品数量、天数、库存限制和价格数据
    private int prodCount; // 商品种类数
    private int dayCount; // 天数
    private int[] stockLimits; // 每种商品的库存量
    private int[][] priceData; // 每种商品的每日价格

    // 构造函数，初始化类成员变量
    public Main(int prodCount, int dayCount, int[] stockLimits, int[][] priceData) {
        this.prodCount = prodCount; // 初始化商品种类数
        this.dayCount = dayCount; // 初始化天数
        this.stockLimits = stockLimits; // 初始化库存限制
        this.priceData = priceData; // 初始化价格数据
    }

    // 计算最大利润的方法
    public int computeMaxProfit() {
        int profit = 0; // 初始化总利润

        // 遍历每种商品
        for (int i = 0; i < prodCount; i++) {
            int[] prices = priceData[i]; // 当前商品的价格数据
            // 遍历每天的价格，从第一天到倒数第二天
            for (int j = 0; j < dayCount - 1; j++) {
                // 如果第二天价格高于第一天，计算利润
                if (prices[j] < prices[j + 1]) {
                    // 利润 = (价格差) * (库存量)
                    profit += (prices[j + 1] - prices[j]) * stockLimits[i];
                }
            }
        }

        return profit; // 返回总利润
    }

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

        // 输入商品数量和天数
        int pCount = sc.nextInt(); // 商品种类数
        int dCount = sc.nextInt(); // 天数

        // 输入每种商品的库存限制
        int[] limits = new int[pCount];
        for (int i = 0; i < pCount; i++) {
            limits[i] = sc.nextInt();
        }

        // 输入每种商品的每日价格
        int[][] prices = new int[pCount][dCount];
        for (int i = 0; i < pCount; i++) {
            for (int j = 0; j < dCount; j++) {
                prices[i][j] = sc.nextInt();
            }
        }

        // 创建 Main 类对象，传入输入的数据
        Main manager = new Main(pCount, dCount, limits, prices);
        // 调用计算利润的方法并输出结果
        System.out.println(manager.computeMaxProfit());
    }
}

js源码：

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

const records = []; // 用于存储所有输入数据
let productCount, tradeDays, maxHoldings; // 商品数量、交易天数、最大库存量

// 监听每一行输入
rl.on("line", (line) => {
  records.push(line); // 将输入的行存储到 records 数组中

  // 如果读取了商品数量、交易天数以及库存信息
  if (records.length === 3) {
    productCount = parseInt(records[0], 10); // 第 1 行：商品数量
    tradeDays = parseInt(records[1], 10); // 第 2 行：交易天数
    maxHoldings = records[2].split(" ").map(Number); // 第 3 行：每种商品的最大库存量
  }

  // 当所有数据读取完毕（商品数量 + 商品价格表）
  if (productCount && records.length === productCount + 3) {
    // 从第 4 行开始是商品的每日价格表
    const priceChanges = records.slice(3).map((entry) => entry.split(" ").map(Number));
    // 计算并输出最大利润
    console.log(maximizeProfit(productCount, tradeDays, maxHoldings, priceChanges));
    rl.close(); // 关闭输入流
  }
});

// 计算最大利润的函数
function maximizeProfit(products, days, holdings, priceTable) {
  let profitSum = 0; // 初始化总利润

  // 遍历每种商品
  for (let idx = 0; idx < products; idx++) {
    // 遍历每天的价格（从第 1 天到倒数第 2 天）
    for (let day = 0; day < days - 1; day++) {
      // 如果后一天的价格高于前一天，可以获利
      if (priceTable[idx][day] < priceTable[idx][day + 1]) {
        // 利润 = (后一天价格 - 前一天价格) * 当前商品的最大库存量
        profitSum += (priceTable[idx][day + 1] - priceTable[idx][day]) * holdings[idx];
      }
    }
  }

  return profitSum; // 返回总利润
}