华为OD机试 - 玩牌高手 - 动态规划（Python/JS/C/C++ 2025 A卷 100分）

华为OD机试 2025A卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。

一、题目描述

给定一个长度为n的整型数组，表示一个选手在n轮内可选择的牌面分数。选手基于规则选牌，

请计算所有轮结束后其可以获得的最高总分数。

选择规则如下：

1. 在每轮里选手可以选择获取该轮牌面，则其总分数加上该轮牌面分数，为其新的总分数；
2. 选手也可不选择本轮牌面直接跳到下一轮，此时将当前总分数还原为3轮前的总分数，若当前轮次小于等于3（即在第1、2、3轮选择跳过轮次），则总分数置为0；
3. 选手的初始总分数为0，且必须依次参加每一轮。

二、输入描述

第一行为一个小写逗号分割的字符串，表示n轮的牌面分数，1<= n <=20。

分数值为整数，-100 <= 分数值 <= 100。

不考虑格式问题。

三、输出描述

所有轮结束后选手获得的最高总分数。

四、测试用例

测试用例1：

1、输入

5,-1,3,-2,4

2、输出

0

3、说明

第1轮: 5
第2轮: 5 + (-1) = 4
第3轮: 4 + 3 = 7
第4轮: 7 + (-2) = 5 或 跳过恢复到第1轮的5
第5轮: 5 + 4 = 9

最优选择策略导致最终总分数为9

测试用例2：

1、输入

10,20,30,40,50

2、输出

150

3、说明

每一轮都选择取牌，总分数为10 + 20 + 30 + 40 + 50 = 150

五、解题思路

题目要求计算选手在每一轮选择牌面后能获得的最高总分数。选手可以选择获取当前轮的牌面分数，也可以选择跳过当前轮。

具体规则如下：

1. 如果选手选择获取当前轮的牌面分数，则将当前轮的牌面分数加到总分数上，成为新的总分数；
2. 如果选手选择跳过当前轮，则将当前总分数还原为3轮前的总分数（即上上轮的总分数），如果当前轮次小于等于3，则总分数置为0；
3. 选手的初始总分数为0，且必须依次参加每一轮。

根据题目描述，我们可以使用动态规划的思想来解决问题。

具体步骤如下：

1. 读取输入的牌面分数字符串，使用逗号分割得到每一轮的牌面分数数组；
2. 创建一个整型数组 arr，将牌面分数依次存储到数组中；
3. 创建一个整型列表 list，用于存储每一轮结束后选手获得的最高总分数。初始化列表的第一个元素为初始总分数，即 list[0] = arr[0]（如果第一轮的牌面分数小于等于0，则初始总分数为0）；
4. 使用循环从第二轮开始计算每一轮结束后选手获得的最高总分数，从 i = 1 开始迭代到 i = n-1：
   • 计算当前轮结束后的总分数 count = list[i-1] + arr[i]，即当前轮的总分数为上一轮的总分数加上当前轮的牌面分数。
   • 如果当前轮次 i 小于等于3，则将 count 和 0 中的较大值添加到列表中，即 list.add(Math.max(count, 0))。这是因为如果当前轮次小于等于3，则选手无法回到上上轮，因此总分数应该置为0。
   • 如果当前轮次 i 大于3，则将 count 和上上轮的总分数 list[i-3] 中的较大值添加到列表中，即 list.add(count > list[i-3] ? count : list[i-3])。这是因为选手可以选择跳过当前轮，所以要比较 count 和跳过当前轮后的总分数，取较大值作为当前轮结束后的最高总分数。
5. 输出列表中的最后一个元素 list[n-1]，即所有轮结束后选手获得的最高总分数。

六、Python算法源码

# 导入所需的库
import sys

def main():
    # 读取输入并转换为整数列表
    arr = list(map(int, sys.stdin.read().strip().split(',')))
    n = len(arr)
    # 初始化动态规划数组
    dp = [0] * n
    
    # 第0轮的处理
    dp[0] = max(arr[0], 0)
    
    # 第1轮的处理
    if n > 1:
        dp[1] = max(dp[0] + arr[1], 0)
    
    # 第2轮的处理
    if n > 2:
        dp[2] = max(dp[1] + arr[2], 0)
    
    # 从第3轮开始处理
    for i in range(3, n):
        dp[i] = max(dp[i - 1] + arr[i], dp[i - 3])
    
    # 输出最终结果
    print(dp[n - 1])

if __name__ == "__main__":
    main()

七、JavaScript算法源码

// 读取输入并处理
process.stdin.resume();
process.stdin.setEncoding('utf8');
let input = '';

process.stdin.on('data', function(chunk) {
    input += chunk;
});

process.stdin.on('end', function() {
    // 将输入的字符串转换为整数数组
    let arr = input.trim().split(',').map(Number);
    let n = arr.length;
    // 初始化动态规划数组
    let dp = new Array(n).fill(0);
    
    // 第0轮的处理
    dp[0] = Math.max(arr[0], 0);
    
    // 第1轮的处理
    if (n > 1) {
        dp[1] = Math.max(dp[0] + arr[1], 0);
    }
    
    // 第2轮的处理
    if (n > 2) {
        dp[2] = Math.max(dp[1] + arr[2], 0);
    }
    
    // 从第3轮开始处理
    for (let i = 3; i < n; i++) {
        dp[i] = Math.max(dp[i - 1] + arr[i], dp[i - 3]);
    }
    
    // 输出最终结果
    console.log(dp[n - 1]);
});

八、C算法源码

#include <stdio.h>
#include <stdlib.h>

// 主函数
int main() {
    char input[1000];
    // 读取输入
    fgets(input, sizeof(input), stdin);
    
    // 解析输入字符串为整数数组
    int arr[20];
    int n = 0;
    char *token = strtok(input, ",");
    while(token != NULL && n < 20) {
        arr[n++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    // 初始化动态规划数组
    int dp[20];
    dp[0] = arr[0] > 0 ? arr[0] : 0;
    
    if(n > 1) {
        dp[1] = (dp[0] + arr[1] > 0) ? dp[0] + arr[1] : 0;
    }
    
    if(n > 2) {
        dp[2] = (dp[1] + arr[2] > 0) ? dp[1] + arr[2] : 0;
    }
    
    // 从第3轮开始处理
    for(int i = 3; i < n; i++) {
        int option1 = dp[i - 1] + arr[i];
        int option2 = dp[i - 3];
        dp[i] = (option1 > option2) ? option1 : option2;
    }
    
    // 输出最终结果
    printf("%d\n", dp[n - 1]);
    return 0;
}

九、C++算法源码

#include <bits/stdc++.h>
using namespace std;

int main(){
    string s;
    // 读取输入
    getline(cin, s);
    // 分割字符串并转换为整数数组
    vector<int> arr;
    int num = 0;
    string temp = "";
    for(char c : s){
        if(c == ','){
            arr.push_back(stoi(temp));
            temp = "";
        }
        else{
            temp += c;
        }
    }
    if(!temp.empty()){
        arr.push_back(stoi(temp));
    }
    int n = arr.size();
    // 初始化动态规划数组
    vector<int> dp(n, 0);
    dp[0] = max(arr[0], 0);
    
    if(n >1){
        dp[1] = max(dp[0] + arr[1], 0);
    }
    
    if(n >2){
        dp[2] = max(dp[1] + arr[2], 0);
    }
    
    // 从第3轮开始处理
    for(int i=3;i<n;i++){
        dp[i] = max(dp[i-1] + arr[i], dp[i-3]);
    }
    
    // 输出最终结果
    cout << dp[n-1] << endl;
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2025 A卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。