【2024华为OD-E卷-100分-虚拟理财游戏】（题目+思路+Java&C++&Python解析)

题目描述

你正在开发一款虚拟理财游戏，玩家可以投资股票，并查看其投资组合的价值。游戏中有 N 只股票，每只股票有一个当前的价格 price[i] 和一个预期的波动率 volatility[i]。

玩家可以在每个时间点进行以下操作之一：

1. 保持当前的投资组合不变。
2. 选择一只股票进行买入（假设买入一股）。
3. 选择一只已持有的股票进行卖出（假设卖出一股）。

你的任务是计算并返回玩家在 K 天后可能拥有的投资组合的最大价值。注意，每天玩家只能进行一次操作，并且玩家初始时没有持有任何股票。

输入：

• N：股票的数量
• price：长度为 N 的数组，表示每只股票的价格
• volatility：长度为 N 的数组，表示每只股票的波动率
• K：天数

输出：

• 玩家在 K 天后可能拥有的投资组合的最大价值

思路

这个问题可以通过动态规划（Dynamic Programming, DP）来解决。我们定义 dp[i][j][k] 表示在第 i 天，持有 j 只股票 k 时可能获得的最大价值。然而，由于股票数量 N 和天数 K 可能很大，这种三维 DP 的空间复杂度会非常高。

为了优化这个问题，我们可以使用一种“背包问题”的思路，并结合股票价格的波动率来优化状态转移。考虑到玩家每天只能进行一次操作，我们可以维护两个状态数组：

1. buy[i][j] 表示在第 i 天买入第 j 只股票后的最大价值。
2. sell[i][j] 表示在第 i 天卖出第 j 只股票后的最大价值。

初始时，我们假设玩家没有持有任何股票，因此 buy[0][j] 和 sell[0][j] 都应该为 -price[j]（因为买入需要支付价格），但实际上 sell[0][j] 应该初始化为一个极小值（比如 -Infinity），因为玩家在第 0 天不可能卖出股票。

对于每一天 i 和每只股票 j：

• 如果玩家选择买入股票 j，则 buy[i][j] 可以从 buy[i-1][j]（前一天买入该股票）或 0（前一天没有操作，今天买入）转移而来，并且需要减去当前价格。
• 如果玩家选择卖出股票 j，则 sell[i][j] 可以从 buy[i-1][j]（前一天买入该股票）转移而来，并且需要加上当前价格，再取 sell[i-1][j]（前一天已经持有该股票并卖出）的最大值。

最终，我们需要在第 K 天对所有股票的最大买入和卖出价值进行取最大值，即为所求结果。

Java 代码实现

import java.util.Arrays;

public class VirtualInvestmentGame {
    public static int maxPortfolioValue(int N, int[] price, int[] volatility, int K) {
        double[][] buy = new double[K + 1][N];
        double[][] sell = new double[K + 1][N];
        
        // Initialize buy and sell arrays
        for (int j = 0; j < N; j++) {
            buy[0][j] = -price[j];
            sell[0][j] = Double.NEGATIVE_INFINITY;
        }
        
        // DP transition
        for (int i = 1; i <= K; i++) {
            for (int j = 0; j < N; j++) {
                buy[i][j] = Math.max(buy[i - 1][j], 0) - price[j];
                sell[i][j] = Math.max(sell[i - 1][j], buy[i - 1][j] + price[j] * volatility[j]);
            }
        }
        
        // Find the maximum value among all sell states on the last day
        double maxValue = 0;
        for (int j = 0; j < N; j++) {
            maxValue = Math.max(maxValue, sell[K][j]);
        }
        
        return (int) Math.max(maxValue, 0); // Ensure non-negative result
    }

    public static void main(String[] args) {
        int N = 3;
        int[] price = {10, 20, 30};
        int[] volatility = {1, 1.5, 1.2};
        int K = 5;
        
        int result = maxPortfolioValue(N, price, volatility, K);
        System.out.println("Max Portfolio Value: " + result);
    }
}

C++ 代码实现

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

using namespace std;

int maxPortfolioValue(int N, vector<int>& price, vector<int>& volatility, int K) {
    vector<vector<double>> buy(K + 1, vector<double>(N, 0));
    vector<vector<double>> sell(K + 1, vector<double>(N, INT_MIN));
    
    // Initialize buy and sell arrays
    for (int j = 0; j < N; j++) {
        buy[0][j] = -price[j];
    }
    
    // DP transition
    for (int i = 1; i <= K; i++) {
        for (int j = 0; j < N; j++) {
            buy[i][j] = max(buy[i - 1][j], 0.0) - price[j];
            sell[i][j] = max(sell[i - 1][j], buy[i - 1][j] + price[j] * volatility[j]);
        }
    }
    
    // Find the maximum value among all sell states on the last day
    double maxValue = 0;
    for (int j = 0; j < N; j++) {
        maxValue = max(maxValue, sell[K][j]);
    }
    
    return max(0, static_cast<int>(maxValue)); // Ensure non-negative result
}

int main() {
    int N = 3;
    vector<int> price = {10, 20, 30};
    vector<int> volatility = {1, 1.5, 1.2};
    int K = 5;
    
    int result = maxPortfolioValue(N, price, volatility, K);
    cout << "Max Portfolio Value: " << result << endl;
    
    return 0;
}

Python 代码实现

def max_portfolio_value(N, price, volatility, K):
    buy = [[-price[j] if i == 0 else float('-inf') for j in range(N)] for i in range(K + 1)]
    sell = [[float('-inf')] * N for _ in range(K + 1)]
    
    # DP transition
    for i in range(1, K + 1):
        for j in range(N):
            buy[i][j] = max(buy[i - 1][j], 0) - price[j]
            sell[i][j] = max(sell[i - 1][j], buy[i - 1][j] + price[j] * volatility[j])
    
    # Find the maximum value among all sell states on the last day
    max_value = max(sell[K])
    
    return max(0, int(max_value))  # Ensure non-negative result

# Example usage
N = 3
price = [10, 20, 30]
volatility = [1, 1.5, 1.2]
K = 5

result = max_portfolio_value(N, price, volatility, K)
print("Max Portfolio Value:", result)