华为OD机试 2024E卷题库疯狂收录中，刷题点这里
专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
一、题目描述
“吃货”和“馋嘴”两人到披萨店点了一份铁盘(圆形)披萨，并嘱咐店员将披萨按放射状切成大小相同的偶数个小块。
但是粗心服务员将披萨切成了每块大小都完全不同奇数块，且肉眼能分辨出大小。
由于两人都想吃到最多的披萨，他们商量了一个他们认为公平的分法:从“吃货”开始，轮流取披萨。
除了第-块披萨可以任意选取以外，其他都必须从缺口开始选。 他俩选披萨的思路不同。
“馋嘴”每次都会选最大块的拨萨，而且“吃货”知道“馋嘴”的想法。
已知披萨小块的数量以及每块的大小，求“吃货”能分得的最大的披萨大小的总和。
二、输入描述
第1行为一个正整数奇数 N ，表示披萨小块数量。其中 3 ≤ N< 500
接下来的第 2 行到第 N+1 （共 N 行），每行为一个正整数，表示第i块披萨的大小， 1≤i≤N 。
披萨小块从某一块开始，按照一个方向次序顺序编号为 1 ~ N ,每块披萨的大小范围为[1,2147483647]。
三、输出描述
”吃货“能分得到的最大的披萨大小的总和。
四、测试用例
测试用例1：
1、输入
3
1
2
3
2、输出
4
3、说明
披萨被切成 3 块，大小分别为 1、2、3。
"吃货"最优策略是先选 3，然后 “馋嘴” 会选 2，最后 “吃货” 选 1。
因此，“吃货” 能获得的最大总和是 3 + 1 = 4。
测试用例2：
4、输入
7
10
20
30
40
50
60
70
5、输出
160
6、说明
披萨被切成 7 块，大小从 10 到 70。
“吃货” 的最优策略是选择 70、50、40，而 “馋嘴” 会选择 60、30、20。
“吃货” 获得的总和是 70 + 50 + 40 = 160。
五、解题思路
- 读取披萨块的数量 n 和每块披萨的大小。
- 使用哈希表存储中间结果以优化递归计算。
- 递归计算：
- 定义一个递归函数 f(l, r, t)，表示在 l 到 r 的范围内，在 t 次轮换中“吃货”可以获得的最大披萨总和。
- 基于剩余次数 t 的不同，计算“吃货”可能的选择。
- 递归模拟“吃货”和“馋嘴”的选取过程。
- 结果计算：
- 遍历所有可能的起始块，从每一块开始计算“吃货”能获得的最大总和。
- 取所有计算结果的最大值。
虽然代码使用递归实现，但本质上是一个自顶向下的动态规划解法。每个子问题的解都可能被多次使用，我们通过缓存这些解来优化性能。
六、Python算法源码
def main():
# 读取披萨块的数量
n = int(input())
pizza = list(map(int, input().split()))
max_sum = 0
# 尝试从每一块披萨开始，找出能获得最大总和的起始位置
for i in range(n):
# pizza[i] 是第一块选择的披萨，f(i-1, i+1, n-1) 计算剩余披萨的最优选择
max_sum = max(max_sum, pizza[i] + f(i - 1, i + 1, n - 1, pizza, {}))
# 输出"吃货"能获得的最大披萨总和
print(max_sum)
def f(l, r, t, pizza, cache):
# 基本情况：如果剩余次数小于等于1，意味着这是"馋嘴"的最后一次选择，"吃货"无法再获得披萨
if t <= 1:
return 0
# 处理循环边界，确保l和r在有效范围内
l = (l + n) % n
r = r % n
# 检查缓存，如果之前计算过这个状态，直接返回缓存的结果
key = (l, r, t)
if key in cache:
return cache[key]
# 模拟"馋嘴"的选择：总是选择较大的一块
if pizza[l] >= pizza[r]:
l = (l - 1 + n) % n # "馋嘴"选择了左边的披萨，左边界向左移动
else:
r = (r + 1) % n # "馋嘴"选择了右边的披萨，右边界向右移动
# 计算"吃货"两种选择的结果：
# 选择左边的披萨
s1 = pizza[l] + f((l - 1 + n) % n, r, t - 2, pizza, cache)
# 选择右边的披萨
s2 = pizza[r] + f(l, (r + 1) % n, t - 2, pizza, cache)
# 选择较大的结果
result = max(s1, s2)
# 将结果存入缓存
cache[key] = result
return result
if __name__ == "__main__":
main()
七、JavaScript算法源码
function main() {
const fs = require('fs');
const input = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n');
const n = parseInt(input[0]);
const pizza = input[1].split(' ').map(Number);
let maxSum = 0;
const cache = new Map();
// 尝试从每一块披萨开始，找出能获得最大总和的起始位置
for (let i = 0; i < n; i++) {
maxSum = Math.max(maxSum, pizza[i] + f(i - 1, i + 1, n - 1, pizza, cache));
}
// 输出"吃货"能获得的最大披萨总和
console.log(maxSum);
}
function f(l, r, t, pizza, cache) {
const n = pizza.length;
// 基本情况：如果剩余次数小于等于1，"吃货"无法再获得披萨
if (t <= 1) {
return 0;
}
// 处理循环边界，确保l和r在有效范围内
l = (l + n) % n;
r = r % n;
// 检查缓存，如果之前计算过这个状态，直接返回缓存的结果
const key = `${l},${r},${t}`;
if (cache.has(key)) {
return cache.get(key);
}
// 模拟"馋嘴"的选择：总是选择较大的一块
if (pizza[l] >= pizza[r]) {
l = (l - 1 + n) % n; // "馋嘴"选择了左边的披萨，左边界向左移动
} else {
r = (r + 1) % n; // "馋嘴"选择了右边的披萨，右边界向右移动
}
// 计算"吃货"两种选择的结果：
const s1 = pizza[l] + f((l - 1 + n) % n, r, t - 2, pizza, cache);
const s2 = pizza[r] + f(l, (r + 1) % n, t - 2, pizza, cache);
// 选择较大的结果
const result = Math.max(s1, s2);
// 将结果存入缓存
cache.set(key, result);
return result;
}
// 如果在Node.js环境中运行，调用main函数
main();
八、C算法源码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_N 100
int n;
int pizza[MAX_N];
int cache[MAX_N][MAX_N][MAX_N];
// 初始化缓存
void init_cache() {
for (int i = 0; i < MAX_N; i++) {
for (int j = 0; j < MAX_N; j++) {
for (int k = 0; k < MAX_N; k++) {
cache[i][j][k] = -1;
}
}
}
}
int f(int l, int r, int t);
// 主函数
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &pizza[i]);
}
int maxSum = 0;
init_cache();
// 尝试从每一块披萨开始，找出能获得最大总和的起始位置
for (int i = 0; i < n; i++) {
maxSum = (pizza[i] + f((i - 1 + n) % n, (i + 1) % n, n - 1) > maxSum) ?
(pizza[i] + f((i - 1 + n) % n, (i + 1) % n, n - 1)) : maxSum;
}
printf("%d\n", maxSum);
return 0;
}
// 递归函数，计算在给定状态下"吃货"能获得的最大披萨总和
int f(int l, int r, int t) {
if (t <= 1) {
return 0;
}
l = (l + n) % n;
r = r % n;
if (cache[l][r][t] != -1) {
return cache[l][r][t];
}
if (pizza[l] >= pizza[r]) {
l = (l - 1 + n) % n;
} else {
r = (r + 1) % n;
}
int s1 = pizza[l] + f((l - 1 + n) % n, r, t - 2);
int s2 = pizza[r] + f(l, (r + 1) % n, t - 2);
cache[l][r][t] = (s1 > s2) ? s1 : s2;
return cache[l][r][t];
}
九、C++算法源码
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;
#define MAX_N 100
int n;
vector<int> pizza(MAX_N);
int cache[MAX_N][MAX_N][MAX_N];
// 初始化缓存
void init_cache() {
memset(cache, -1, sizeof(cache));
}
int f(int l, int r, int t);
// 主函数
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> pizza[i];
}
int maxSum = 0;
init_cache();
// 尝试从每一块披萨开始，找出能获得最大总和的起始位置
for (int i = 0; i < n; i++) {
maxSum = max(maxSum, pizza[i] + f((i - 1 + n) % n, (i + 1) % n, n - 1));
}
cout << maxSum << endl;
return 0;
}
// 递归函数，计算在给定状态下"吃货"能获得的最大披萨总和
int f(int l, int r, int t) {
if (t <= 1) {
return 0;
}
l = (l + n) % n;
r = r % n;
if (cache[l][r][t] != -1) {
return cache[l][r][t];
}
if (pizza[l] >= pizza[r]) {
l = (l - 1 + n) % n;
} else {
r = (r + 1) % n;
}
int s1 = pizza[l] + f((l - 1 + n) % n, r, t - 2);
int s2 = pizza[r] + f(l, (r + 1) % n, t - 2);
cache[l][r][t] = max(s1, s2);
return cache[l][r][t];
}
🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
891
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
