【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DP】2024D-分披萨【欧弟算法】全网注释最详细分类最全的华为OD真题题解

已于 2024-08-09 01:55:55 修改
阅读量553 收藏 4
点赞数 12
分类专栏： # dp 文章标签： 算法 java c++ python leetcode 华为od
于 2024-08-09 01:49:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48157259/article/details/141039951
版权

可上 欧弟OJ系统 练习华子OD、大厂真题
绿色聊天软件戳 od1441了解算法冲刺训练（备注【CSDN】否则不通过）

文章目录

相关推荐阅读

从2024年4月15号开始，OD机考全部配置为2024D卷。
注意两个关键点：

  1. 会遇到C卷复用题。虽然可能存在幸存者偏差，但肯定还会有一大部分的旧题。
  2. 现在又支持做完题目之后倒回去改了。就是可以先做200的再做100的，然后可以反复提交。
    在这里插入图片描述

题目描述与示例

题目描述

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

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

“馋嘴”每次都会选最大块的披萨，而且“吃货"知道“馋嘴”的想法。

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

输入描述

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

接下来的第2行到第N+1行(共N行)，每行为一个正整数，表示第ì块披萨的大小。1 <= i <= N。

披萨小块从某一块开始，按照一个方向依次顺序编号为1~N。每块披萨的大小范围为[1,21474836471]。

输出描述

“吃货”能分得的最大的披萨大小的总和。

示例

输入

5
8
2
10
5
7

输出

19

解题思路

Q：这题所提供的数组要求是环形的，怎么处理？

A：将数组复制一次，拼接在原数组后面。因此，到时候取a[0...n-1],a[1...n],a[2...n+1],...中的最优一个解即可。

我们考虑动态规划三部曲：

  1. dp数组的含义是什么？
  • dp数组是一个长度为(n+n) * (n+n) 的二维列表，f[i][j]表示吃货将a[i...j]中所有的披萨吃完后，吃货得到的最多披萨量。需要保证披萨的数量是奇数块，即(j-i+1)%2=1。
  1. 动****态转移方程是什么？

需要求解f[i][j]。吃货有两种选择，一种是a[i]（剩下a[i+1...j]，如果馋嘴觉得a[i+1]>a[j]，只剩下a[i+2...j]，对应f[i+2][j]，f[i][j]=f[i+2][j]+a[i]；如果馋嘴觉得a[i+1]<a[j]，只剩下i+1...j-1，对应f[i+1][j-1]，f[i][j]=f[i+1][j-1]+a[i]）；

一种是a[j]（剩下a[i...j-1]，如果馋嘴觉得a[i]>a[j-1]，只剩下i+1...j-1，对应f[i+1][j-1]，f[i][j]=f[i+1][j-1]+a[j]；如果馋嘴觉得a[i]<a[j-1]，只剩下i...j-2，对应f[i][j-2]，f[i][j]=f[i][j-2]+a[j])。

for k in range(3, n + 1, 2):
    for i in range(n + n - k + 1):
        j = i + k - 1
        # 选择a[i]，只剩下a[i+1...j]
        if a[i+1] > a[j]:
            f[i][j] = max(f[i][j], f[i+2][j] + a[i])
        else:
            f[i][j] = max(f[i][j], f[i+1][j-1] + a[i])
        
        # 选择a[j]，只剩下a[i...j-1]
        if a[i] > a[j-1]:
            f[i][j] = max(f[i][j], f[i+1][j-1] + a[j])
        else:
            f[i][j] = max(f[i][j], f[i][j-2] + a[j])
  1. dp数组如何初始化？
  • 一开始，如果只有一块披萨a[i...i]的话，吃货吃下a[i]，因此有f[i][i]=a[i]。
f = [[0 for _ in range(n + n)] for _ in range(n + n)]
for i in range(n + n):
    f[i][i] = a[i]

最终求解出f数组，那么由于我们给定的是环形披萨，因此全局的最大值max(f[0][n-1],f[1][n],...,f[n-1][n+n-2])。

代码

python

# 题目：【DP】2024D-分披萨
# 分值：100
# 作者：黄老师-Chiya
# 算法：DP
# 代码看不懂的地方，请直接在群上提问


# 输入披萨块的数量N
n = int(input())

# 用于存储每块披萨大小的列表
a = []
# 读入每块披萨的大小
for _ in range(n):
    a.append(int(input()))
# 由于披萨是环形的，可以从任一位置开始，所以将数组扩展一倍以方便处理环形结构
a += a

# 初始化动态规划表，用于存储从i到j片披萨，吃货能吃到的最大披萨大小
f = [[0 for _ in range(n + n)] for _ in range(n + n)]
for i in range(n + n):
    # 当只有一块披萨时，直接取该块披萨的大小
    f[i][i] = a[i]

# k表示考虑的披萨块的长度，从3开始因为必须是奇数块，每次增加2
for k in range(3, n + 1, 2):
    for i in range(n + n - k + 1):
        j = i + k - 1
        # 选择a[i]时的处理逻辑：检查馋嘴接下来会选哪块，并更新状态
        if a[i+1] > a[j]:
            # 如果馋嘴选a[i+1]，则吃货的选择从i+2到j的披萨
            f[i][j] = max(f[i][j], f[i+2][j] + a[i])
        else:
            # 如果馋嘴选a[j]，则吃货的选择从i+1到j-1的披萨
            f[i][j] = max(f[i][j], f[i+1][j-1] + a[i])
        
        # 选择a[j]时的处理逻辑：同样检查馋嘴接下来会选哪块，并更新状态
        if a[i] > a[j-1]:
            # 如果馋嘴选a[i]，则吃货的选择从i+1到j-1的披萨
            f[i][j] = max(f[i][j], f[i+1][j-1] + a[j])
        else:
            # 如果馋嘴选a[j-1]，则吃货的选择从i到j-2的披萨
            f[i][j] = max(f[i][j], f[i][j-2] + a[j])

# 求解所有可能的环形起点的最大值
ans = 0
for i in range(n):
    ans = max(ans, f[i][i + n - 1])
# 输出最终结果
print(ans)

java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入披萨块的数量N
        int n = scanner.nextInt();

        // 用于存储每块披萨大小的数组
        int[] a = new int[2 * n];
        // 读入每块披萨的大小
        for (int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
            // 由于披萨是环形的，将数组扩展一倍以方便处理环形结构
            a[i + n] = a[i];
        }

        // 初始化动态规划表，用于存储从i到j片披萨，吃货能吃到的最大披萨大小
        long[][] f = new long[2 * n][2 * n];
        for (int i = 0; i < 2 * n; i++) {
            // 当只有一块披萨时，直接取该块披萨的大小
            f[i][i] = a[i];
        }

        // k表示考虑的披萨块的长度，从3开始因为必须是奇数块，每次增加2
        for (int k = 3; k <= n; k += 2) {
            for (int i = 0; i < 2 * n - k + 1; i++) {
                int j = i + k - 1;
                // 选择a[i]时的处理逻辑：检查馋嘴接下来会选哪块，并更新状态
                if (a[i + 1] > a[j]) {
                    // 如果馋嘴选a[i+1]，则吃货的选择从i+2到j的披萨
                    f[i][j] = Math.max(f[i][j], f[i + 2][j] + a[i]);
                } else {
                    // 如果馋嘴选a[j]，则吃货的选择从i+1到j-1的披萨
                    f[i][j] = Math.max(f[i][j], f[i + 1][j - 1] + a[i]);
                }

                // 选择a[j]时的处理逻辑：同样检查馋嘴接下来会选哪块，并更新状态
                if (a[i] > a[j - 1]) {
                    // 如果馋嘴选a[i]，则吃货的选择从i+1到j-1的披萨
                    f[i][j] = Math.max(f[i][j], f[i + 1][j - 1] + a[j]);
                } else {
                    // 如果馋嘴选a[j-1]，则吃货的选择从i到j-2的披萨
                    f[i][j] = Math.max(f[i][j], f[i][j - 2] + a[j]);
                }
            }
        }

        // 求解所有可能的环形起点的最大值
        long ans = 0;
        for (int i = 0; i < n; i++) {
            ans = Math.max(ans, f[i][i + n - 1]);
        }
        // 输出最终结果
        System.out.println(ans);

        scanner.close();
    }
}

cpp

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

using namespace std;

int main() {
    // 输入披萨块的数量N
    int n;
    cin >> n;

    // 用于存储每块披萨大小的向量
    vector<int> a(2 * n, 0); // 初始化大小为2n的向量，初值为0
    // 读入每块披萨的大小
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        a[i + n] = a[i]; // 由于披萨是环形的，将数组扩展一倍以方便处理环形结构
    }

    // 初始化动态规划表，用于存储从i到j片披萨，吃货能吃到的最大披萨大小
    vector<vector<long long>> f(2 * n, vector<long long>(2 * n, 0));
    for (int i = 0; i < 2 * n; ++i) {
        // 当只有一块披萨时，直接取该块披萨的大小
        f[i][i] = a[i];
    }

    // k表示考虑的披萨块的长度，从3开始因为必须是奇数块，每次增加2
    for (int k = 3; k <= n; k += 2) {
        for (int i = 0; i < 2 * n - k + 1; ++i) {
            int j = i + k - 1;
            // 选择a[i]时的处理逻辑：检查馋嘴接下来会选哪块，并更新状态
            if (a[i + 1] > a[j]) {
                // 如果馋嘴选a[i+1]，则吃货的选择从i+2到j的披萨
                f[i][j] = max(f[i][j], f[i + 2][j] + a[i]);
            } else {
                // 如果馋嘴选a[j]，则吃货的选择从i+1到j-1的披萨
                f[i][j] = max(f[i][j], f[i + 1][j - 1] + a[i]);
            }

            // 选择a[j]时的处理逻辑：同样检查馋嘴接下来会选哪块，并更新状态
            if (a[i] > a[j - 1]) {
                // 如果馋嘴选a[i]，则吃货的选择从i+1到j-1的披萨
                f[i][j] = max(f[i][j], f[i + 1][j - 1] + a[j]);
            } else {
                // 如果馋嘴选a[j-1]，则吃货的选择从i到j-2的披萨
                f[i][j] = max(f[i][j], f[i][j - 2] + a[j]);
            }
        }
    }

    // 求解所有可能的环形起点的最大值
    long long ans = 0;
    for (int i = 0; i < n; ++i) {
        ans = max(ans, f[i][i + n - 1]);
    }
    // 输出最终结果
    cout << ans << endl;

    return 0;
}

时空复杂度

时间复杂度：O(N^2)。双重循环所需时间复杂度

空间复杂度：O(N^2)，因为开辟了一个大小为2N * 2N的数组。

华为OD算法/大厂面试高频题算法练习冲刺训练

  • 华为OD算法/大厂面试高频题算法冲刺训练目前开始常态化报名！目前已服务300+同学成功上岸！

  • 课程讲师为全网50w+粉丝编程博主@吴师兄学算法 以及小红书头部编程博主@闭着眼睛学数理化

  • 每期人数维持在20人内，保证能够最大限度地满足到每一个同学的需求，达到和1v1同样的学习效果！

  • 60+天陪伴式学习，40+直播课时，300+动画图解视频，300+LeetCode经典题，200+华为OD真题/大厂真题，还有简历修改、模拟面试、专属HR对接将为你解锁

  • 可上全网独家的欧弟OJ系统练习华子OD、大厂真题

  • 可查看链接 大厂真题汇总 & OD真题汇总(持续更新)

  • 绿色聊天软件戳 od1336了解更多

闭着眼睛学算法
关注
  • 12
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【模拟】2024D-灰度图恢复【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
04-26 1814
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DP】2024D-分月饼【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
07-15 1462
有LeetCode算法/华为OD考试扣扣交流群可加可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DP】2024D-抢7游戏【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
06-20 1252
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【回溯】2024D-表演赛游戏分组【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
04-22 1138
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1336了解算法冲刺训练。
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DP】2024D-园区参观路径【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
06-19 740
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DP】2024D-跳格子(3)【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
07-15 955
有LeetCode算法/华为OD考试扣扣交流群可加可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
2024华为OD机考机试 真题目录（C卷 + D卷 + B卷 + A卷） + 考点说明
热门推荐
算法大师，励志更新全网最全的算法题库！
03-18 36万+
OD，全称(Outsourcing Dispacth)模式，目前华为和德科联合招聘的简称。华为社招基本都是OD招聘，17级以下都是OD模式（13-17）。
【Py/Java/C++三种语言OD2023C卷真题】20天拿下华为OD笔试之【模拟/数学】2023C-多段线数据压缩【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
03-01 1460
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1336了解算法冲刺训练。
2024华为OD机试（Python）真题【A卷+B卷+C卷+D卷】目录
MISAYAONE的博客
11-20 18万+
2022.11 开始机试应该是换新题库了，优先更新最新的题目。
华为OD机试ABC+OJ（Java & JS & Py）2024+2023+2022年.rar
03-29
本压缩包文件包含了从2022年至2024年的华为OD机试题目，涉及的语言主要为Java、JavaScript和Python，这些都是IT行业中广泛应用的编程语言。 Java是一种面向对象的、高性能的、跨平台的编程语言，尤其在企业级应用和...
华为od机试代码Python语言
07-20
【华为OD机试代码Python语言】是针对华为在线开发者（OD）面试的编程题目的解决方案集，主要使用Python语言编写。这些题目来源于牛客网和CSDN等平台，涵盖了不同的算法和编程挑战，旨在检验候选人在实际问题解决中的...
华为OD题分糖果猴子吃桃服务器广播和最大的子矩阵gpu耗时最大子矩阵和最大的字串计算字符串数量正方体翻面计算最短步长py3.9
08-23
华为OD题分糖果猴子吃桃服务器广播和最大的子矩阵gpu耗时最大子矩阵和最大的字串计算字符串数量正方体翻面计算最短步长py3.9
华为OD机考三道题的代码，以及考试过程中的一个记录
06-01
在“HuaWeiOD-master”文件夹中，每一道题目的代码可能是以单独的文件存在，命名可能为“Question1.py”、“Question2.java”等，对应不同的编程语言。代码文件通常会包含完整的解决问题的逻辑，包括输入处理、算法...
华为研发笔试题西安Java-huawei-lte-examples:使用pythonhuawei-lte-apiapi的代码示例
06-17
华为研究笔试题西安Java华为LTE频段 要求 python3 (>3.6) pip3 混帐 基维 安装 安装依赖 git clone git@github.com:littlejo/huawei-lte-examples.git cd huawei-lte-examples/huawei-lte-band pip3 install -r ...
CSP 2020 第三题：表达式
最新发布
m0_46183615的博客
08-03 520
CSP 2020 第三题：表达式
5力扣：最长回文子串
m0_75015083的博客
08-02 382
从后到前遍历是为了让每一次遍历时所需用到的子串提前被计算过。
VRF 算法流程及代码实现
smilejiasmile的博客
08-03 222
Verifiable Random Functions (VRFs) 是一种密码学原语，能够为给定输入生成一个随机输出，并提供一个可以验证的证明，证明输出是由特定输入生成的。VRFs 具有许多应用，包括区块链、分布式系统和安全协议。使用secp256k1曲线可以产生确定性签名，适用于 VRF 实现。通过使用 HMAC-SHA256 生成确定性随机数k，可以确保签名过程对相同的输入始终产生相同的结果，从而满足 VRF 的要求。
代码随想录算法训练营第三十三天 | 动态规划理论基础、509. 斐波那契数、70. 爬楼梯、746. 使用最小花费爬楼梯
weixin_43581681的博客
08-01 353
1. 动态规划基础；2. 背包问题；3. 打家劫舍；4. 股票问题；5. 子序列问题。1. 确定 dp[ i ] 数组及下标含义；2. 确定递推公式；3.确定dp数组如何初始化；4. 确定遍历顺序（背包问题中很重要）；5. 举例推导dp数组。
华为od机试2022&2023(c++java js py)
01-31
华为OD（开发者）机试2022是华为公司针对技术人才举办的一项在线笔试考试，旨在选拔优秀的开发者和工程师加入华为公司。在机试中，参与者需要完成一系列的编程题目和算法题目，以检验其在编程和算法方面的能力和水平。通过机试，华为公司可以全面了解应聘者的技术能力，包括编程基础、算法思维、逻辑分析和问题解决能力等。机试内容通常涵盖数据结构、算法设计、程序设计和数据库等方面的题目，参与者需要在规定的时间内完成题目，以展现其在高压环境下解决问题的能力。 对于参与者来说，通过华为OD机试2022可以获取到一次展示自己技术能力的机会，同时也是加入华为公司的第一步。优秀的表现可以为自己的技术职业生涯打下良好的基础，同时也有机会获得华为公司的面试机会，进一步向心仪的职位发起挑战。 总之，华为OD机试2022是华为公司选拔优秀技术人才的一项重要环节，对于参与者来说是一次展示自身技术能力并获得就业机会的难得机遇。希望每一位参与者能够充分准备，发挥出自己的潜力，在机试中脱颖而出，获得自己心仪的职业发展机会。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值