(B卷,100分)- 玩牌高手（Java & JS & Python & C）

题目描述

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

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

选择规则如下：

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

输入描述

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

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

不考虑格式问题。

输出描述

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

用例

题目解析

这题是一道简单的动态规划的题目，因为每一轮的总分都与前面轮次的总分有状态转移关系。

比如 1,-5,-6,4,3,6,-2

第1轮，牌面1，我们选了的话，总分1，不选的话，总分0，而本轮总分正数的话，对后面轮总分有益，因此我们选牌面1，让总分为1

第2轮，牌面-5，我们选了的话，总分-5+1=-4，不选的话，总分重置为0，因此我们不选，因为负数总分对后面轮次总分无益，此时总分为0

第3轮，牌面-6，同样不选，总分为0

第4轮，牌面4，选，总分4

第5轮，牌面3，选，总分7

第6轮，牌面6，选，总分13

第7轮，牌面-2，如果我们不选，则总分将还原为3轮前的总分数，即第4轮，总分变为4，如果我们选了，则总分为13-2=11，而11>4，因此我们选牌面-2

最终最高总分为11。

通过上面逻辑我们可以总结出状态转移方程如下：

dp[0] = max(arr[0], 0)

dp[i] = max(dp[i-1] + arr[i], 0)    ,  1<=i<=2

dp[i] = max(dp[i-1] + arr[i], dp[i-3]),  i>2

dp数组用于存储每轮的最高总分。

JavaScript算法源码

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");

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

rl.on("line", (line) => {
  const arr = line.split(",").map((ele) => parseInt(ele));

  console.log(getMaxScore(arr));
});

function getMaxScore(arr) {
  const dp = [];

  for (let i = 0; i < arr.length; i++) {
    if (i === 0) {
      dp[0] = Math.max(arr[0], 0);
    } else if (i > 0 && i < 3) {
      dp[i] = Math.max(dp[i - 1] + arr[i], 0);
    } else {
      dp[i] = Math.max(dp[i - 1] + arr[i], dp[i - 3]);
    }
  }

  return dp.pop();
}

Java算法源码

import java.util.Arrays;
import java.util.Scanner;
 
public class Main {
  // 输入获取
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
 
    Integer[] arr =
        Arrays.stream(sc.nextLine().split(",")).map(Integer::parseInt).toArray(Integer[]::new);
 
    System.out.println(getResult(arr));
  }
 
  // 算法入口
  public static int getResult(Integer[] arr) {
    int n = arr.length;
 
    int[] dp = new int[n];
 
    for (int i = 0; i < n; i++) {
      if (i == 0) {
        dp[0] = Math.max(0, arr[0]);
      } else if (i < 3) {
        dp[i] = Math.max(0, dp[i - 1] + arr[i]);
      } else {
        dp[i] = Math.max(dp[i - 3], dp[i - 1] + arr[i]);
      }
    }
 
    return dp[n - 1];
  }
}

Python算法源码

# 输入获取
arr = list(map(int, input().split(",")))
 
 
# 算法入口
def getResult():
    n = len(arr)
 
    dp = [0] * n
 
    for i in range(n):
        if i == 0:
            dp[0] = max(0, arr[0])
        elif i < 3:
            dp[i] = max(0, dp[i - 1] + arr[i])
        else:
            dp[i] = max(dp[i - 3], dp[i - 1] + arr[i])
 
    return dp[-1]
 
 
# 算法调用
print(getResult())

C算法源码

#include <stdio.h>

#define MAX(a,b) (a) > (b) ? (a) : (b)

#define MAX_SIZE 20

int getResult(int nums[], int nums_size);

int main() {
    int nums[MAX_SIZE];
    int nums_size = 0;

    while(scanf("%d", &nums[nums_size++])) {
        if(getchar() != ',') break;
    }

    printf("%dn", getResult(nums, nums_size));

    return 0;
}

int getResult(int nums[], int nums_size) {
    int dp[nums_size];

    for(int i=0; i<nums_size; i++) {
        if(i == 0) {
            dp[0] = MAX(0, nums[0]);
        } else if(i < 3) {
            dp[i] = MAX(0, dp[i-1] + nums[i]);
        } else {
            dp[i] = MAX(dp[i-3], dp[i-1] + nums[i]);
        }
    }

    return dp[nums_size-1];
}