华为OD笔试机试 - 分披萨 (c++ 2024年C卷D卷)

华为OD机试（C卷+D卷）2024真题目录(Java & c++ & python)

题目描述

"吃货"和"馋嘴"两人到披萨店点了一份铁盘（圆形）披萨，并嘱咐店员将披萨按放射状切成大小相同的偶数个小块。但是粗心的服务员将披萨切成了每块大小都完全不同奇数块，且肉眼能分辨出大小。

由于两人都想吃到最多的披萨，他们商量了一个他们认为公平的分法：从"吃货"开始，轮流取披萨。除了第一块披萨可以任意选取外，其他都必须从缺口开始选。

他俩选披萨的思路不同。"馋嘴"每次都会选最大块的披萨，而且"吃货"知道"馋嘴"的想法。

已知披萨小块的数量以及每块的大小，求"吃货"能分得的最大的披萨大小的总和。

输入描述

第 1 行为一个正整数奇数 N，表示披萨小块数量。

• 3 ≤ N < 500

接下来的第 2 行到第 N + 1 行（共 N 行），每行为一个正整数，表示第 i 块披萨的大小

• 1 ≤ i ≤ N

披萨小块从某一块开始，按照一个方向次序顺序编号为 1 ~ N

• 每块披萨的大小范围为 [1, 2147483647]

输出描述

"吃货"能分得到的最大的披萨大小的总和。

示例1

输入

5
8
2
10
5
7

输出

19

说明：

此例子中，有 5 块披萨。每块大小依次为 8、2、10、5、7。
按照如下顺序拿披萨，可以使"吃货"拿到最多披萨：
“吃货” 拿大小为 10 的披萨
“馋嘴” 拿大小为 5 的披萨
“吃货” 拿大小为 7 的披萨
“馋嘴” 拿大小为 8 的披萨
“吃货” 拿大小为 2 的披萨
至此，披萨瓜分完毕，"吃货"拿到的披萨总大小为 10 + 7 + 2 = 19
可能存在多种拿法，以上只是其中一种。

解题思路

披萨的初始状态如图：

1. 从"吃货"开始，轮流取披萨。除了第一块披萨可以任意选取外，其他都必须从缺口开始选。所以“吃货”先选走10
   

2. "馋嘴"每次都会选最大块的披萨，所以从缺口两端中选走较大的5

3. 此时无论吃货无论选哪个，馋嘴下一轮肯定选走8，因此吃货此轮选走7更优，最后剩一个2给吃货。

记忆化搜索，从而找到最优的状态，使用递归实现。

1. 第一轮，"吃货"可以拿任意一块披萨。而"吃货"拿完后，披萨铁盘就会产生缺口，而"馋嘴"取走披萨是明确的，就是缺口左右两边中较大者
2. 后续每轮，吃货则有两种选择，此时递归两个分支，通过缓存实现记忆化来减少重复计算状态，而馋嘴的选择固定是两者之中的较大值。
3. 由于是总个数是奇数，所以最后一块也是吃货的，也是结束标志。

参考代码

#include <bits/stdc++.h>
 
using namespace std;
 
// 披萨数量（奇数个）
int n;
// n个披萨的大小（各不相同）
int pizza[500];
 
// 缓存
long cache[500][500];
 
int check(int idx) {
    if (idx < 0) {
        idx = n - 1;
    } else if (idx >= n) {
        idx = 0;
    }
 
    return idx;
}
 
long recursive(int left, int right) {
    // 进入递归前，"吃货"已经拿了披萨，因此进入递归后，轮到"馋嘴"拿
    // 而"馋嘴"拿披萨的策略固定是：缺口左右两边中较大的那块
    if (pizza[left] > pizza[right]) { // 注意披萨大小各部相同，因此要么左边大，要么右边大，不存在相等的情况
        // 拿走第 left 块，因此缺口左边的位置变为 left - 1
        left = check(left - 1);
    } else {
        // 拿走第 right 块，因此缺口右边的位置变为 right + 1
        right = check(right + 1);
    }
 
    // 缓存优化，如果对应缺口状态的披萨铁盘结果已经算过了，则无需再次重复递归
    if (cache[left][right] > 0) {
        return cache[left][right];
    }
 
    if (left == right) {
        // 缓存对应缺口状态下，吃货可得的最大披萨大小
        cache[left][right] = pizza[left];
    } else {
        // 缓存对应缺口状态下，吃货可得的最大披萨大小
        cache[left][right] = max(recursive(check(left - 1), right) + pizza[left], recursive(left, check(right + 1)) + pizza[right]);
    }
 
    return cache[left][right];
}
 
int main() {
    cin >> n;
 
    for (int i = 0; i < n; i++) {
        cin >> pizza[i];
    }
 
    // ans记录"吃货"能获得的最大披萨大小
    long ans = 0;
    // i 指向首轮被"吃货"选取的披萨位置，可以理解为缺口位置，相当于给环切了一个口
    for (int i = 0; i < n; i++) {
        // i - 1 是缺口的左边披萨，check函数作用是防止 i - 1 越界, 进行绕环运动
        // i + 1 是缺口的右边披萨，check函数作用是防止 i + 1 越界，进行绕环运动
        // recursive的作用求解是"吃货"从缺失了 第 i 块的披萨铁盘 开始选，最终可得的最大披萨大小，
        // 而第 i 块是首轮就被"吃货"拿走的，因此是recursive + pizza[i]
        ans = max(ans, recursive(check(i - 1), check(i + 1)) + pizza[i]);
    }
 
    cout << ans << endl;
 
    return 0;
}