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

已于 2024-08-21 02:52:08 修改
阅读量411 收藏 6
点赞数 9
分类专栏： # dp 最新华为OD真题 文章标签： java c++ 华为od python 算法 leetcode
于 2024-08-21 02:14:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48157259/article/details/141371945
版权

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

文章目录

相关推荐阅读

从2024年8月14号开始，OD机考全部配置为2024E卷。
注意几个关键点：

  1. 大部分的题目仍为往期2023A+B+C以及2024D的旧题。注意万变不离其宗，把方法掌握，无论遇到什么题目都可以轻松应对。
  2. 支持多次提交题目，以最后一次提交为准。可以先做200的再做100的，然后可以反复提交。
  3. E卷仍然为单机位+屏幕监控的形式进行监考。
  4. 进入考试界面新加入了这样一段话并且用红字标出，可以看出华子对作弊代考等行为是0容忍的，请各位同学认真学习，不要妄图通过其他违规途径通过考试。
    在这里插入图片描述

在这里插入图片描述

题目描述与示例

题目描述

某个充电站，可提供n个充电设备，每个充电设备均有对应的输出功率。

任意个充电设备组合的输出功率总和，均构成功率集合P的一个元素。

功率集合P的最优元素，表示最接近充电站最大输出功率p_max的元素。

输入描述

输入为3行：

第一行：充电设备个数n

第二行：每个充电设备的输出功率

第三行：充电站最大输出功率p_max

输出描述

功率集合P的最优元素

补充说明：

  1. 充电设备个数n`` ``>`` ``0
  2. 最优元素必须小于或等于充电站最大输出功率p_max

示例一

输入

3
1 2 3
5

输出

5

说明

示例二

输入

3
2 3 10
9

输出

5

说明

选择功率为2，3的设备构成功率集合，总功率为5，最接近最大功率9。不能选择设备10，因为已经超过了最大功率9。

解题思路

本题属于路径无关、判断是否能够取到某值的01背包问题。

具体讲解可见2023/07/07 真题讲解 （动态规划背包问题专题）。

代码

python

2维DP数组

# 题目：2024E-充电设备
# 分值：100
# 作者：许老师-闭着眼睛学数理化
# 算法：背包DP/二维DP数组
# 代码看不懂的地方，请直接在群上提问

# 输入充电设备数量
n = int(input())
# 输入n个充电设备的功率
devices = list(map(int, input().split()))
# 输入最大充电功率
p_max = int(input())


# 构建二维dp数组，长度为(n+1)*(p_max+1)，为布尔类型的二维数组
# dp[i][j]的含义为
# 在考虑第i个设备时，功率j是否能够取到
dp = [[False] * (p_max+1) for _ in range(n+1)]
# 初始化dp[0][0]为True，表示可以取到
dp[0][0] = True

# 遍历每一种设备的功率p
# 注意为了和二维dp数组的索引一一对应，故i从1开始，取到n结束
for i in range(1, n+1):
    # i是从1开始计数的，故p应为devices[i-1]
    p = devices[i-1]
    # 遍历dp[i-1]数组，所有可以取到的功率总和，用pre_p表示
    for pre_p in range(0, p_max+1):
        # 假如某个功率总和pre_p可以取到，则更新到dp[i][pre_p]
        if dp[i-1][pre_p] == True:
            dp[i][pre_p] = True
            # 假如从某个功率总和pre_p出发，加上当前的设备功率p
            # 能够取得的总设备功率为cur_p
            cur_p = p + pre_p
            # 如果cur_0没有超出最大功率限制
            if cur_p <= p_max:
                # 则cur_p是一个可以取得的方案，将dp[i][cur_p]修改为True
                dp[i][cur_p] = True

# 输出dp[-1]数组中为True的最大值，即为小于等于p_max的最大功率
print(max((i for i in range(p_max+1) if dp[-1][i])))

1维DP数组

# 题目：2024E-充电设备
# 分值：100
# 作者：许老师-闭着眼睛学数理化
# 算法：背包DP/一维DP数组
# 代码看不懂的地方，请直接在群上提问


# 输入充电设备数量
n = int(input())
# 输入n个充电设备的功率
devices = list(map(int, input().split()))
# 输入最大充电功率
p_max = int(input())

# 构建一维dp数组，长度为(p_max+1)，为布尔类型的数组
# dp[i]功率i是否能够取到
dp = [False] * (p_max+1)
# 初始化dp[0]为True，表示可以取到
dp[0] = True

# 遍历每一种设备的功率p
for p in devices:
    # 遍历当前dp数组，所有可以取到的功率总和，用pre_p表示
    # 这里必须使用拷贝，因为在本次遍历中，dp数组会发生改变
    # dp数组正在发生的改变，不能在遍历中被考虑
    #
    # 另一种可行的方法是，逆序遍历dp数组
    # 这样可以保证大功率的修改总是发生在遇到小功率之前
    temp = dp[:]
    for pre_p in range(0, p_max+1):
        # 假如从某个功率总和pre_p出发，加上当前的设备功率p
        # 能够取得的总设备功率为cur_p
        if temp[pre_p] == True:
            cur_p = p + pre_p
            # 如果cur_0没有超出最大功率限制
            if cur_p <= p_max:
                # 则cur_p是一个可以取得的方案，将dp[cur_p]修改为True
                dp[cur_p] = True

# 输出dp数组中为True的最大值，即为小于等于p_max的最大功率
print(max((i for i in range(p_max+1) if dp[i] == True)))

1维DP哈希表

# 题目：2024E-充电设备
# 分值：100
# 作者：许老师-闭着眼睛学数理化
# 算法：背包DP/一维DP哈希表
# 代码看不懂的地方，请直接在群上提问


# 输入充电设备数量
n = int(input())
# 输入n个充电设备的功率
devices = list(map(int, input().split()))
# 输入最大充电功率
p_max = int(input())


# 构建dp哈希集合，集合中的元素表示能够出现的功率总和
dp = set()
# 初始化dp哈希集合包含0，表示不选择任何设备的方案，此时功率总和为0
dp.add(0)


# 遍历每一种设备的功率p
for p in devices:
    # 遍历当前dp哈希集合中，所有可以取到的功率总和，用pre_p表示
    for pre_p in list(dp):
        # 假如从某个功率总和pre_p出发，加上当前的设备功率p
        # 能够取得的总设备功率为cur_p
        cur_p = p + pre_p
        # 如果cur_0没有超出最大功率限制
        if cur_p <= p_max:
            # 则cur_p是一个可以取得的方案，加入dp哈希集合中
            dp.add(cur_p)


# 输出dp数组中的最大值，即为小于等于p_max的最大功率
print(max(dp))

java

2维DP数组

import java.util.*;

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

        int n = input.nextInt();
        int[] devices = new int[n];
        for (int i = 0; i < n; i++) {
            devices[i] = input.nextInt();
        }
        int p_max = input.nextInt();

        boolean[][] dp = new boolean[n + 1][p_max + 1];
        dp[0][0] = true;

        for (int i = 1; i <= n; i++) {
            int p = devices[i - 1];
            for (int pre_p = 0; pre_p <= p_max; pre_p++) {
                if (dp[i - 1][pre_p]) {
                    dp[i][pre_p] = true;
                    int cur_p = p + pre_p;
                    if (cur_p <= p_max) {
                        dp[i][cur_p] = true;
                    }
                }
            }
        }

        int maxPower = -1;
        for (int i = 0; i <= p_max; i++) {
            if (dp[n][i]) {
                maxPower = i;
            }
        }

        System.out.println(maxPower);
    }
}

1维DP数组

import java.util.*;

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

        int n = input.nextInt();
        List<Integer> devices = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            devices.add(input.nextInt());
        }
        int pMax = input.nextInt();

        boolean[] dp = new boolean[pMax + 1];
        dp[0] = true;

        for (int p : devices) {
            boolean[] temp = dp.clone();
            for (int preP = 0; preP <= pMax; preP++) {
                if (temp[preP]) {
                    int curP = p + preP;
                    if (curP <= pMax) {
                        dp[curP] = true;
                    }
                }
            }
        }

        int maxP = -1;
        for (int i = 0; i <= pMax; i++) {
            if (dp[i]) {
                maxP = i;
            }
        }

        System.out.println(maxP);
    }
}

1维DP哈希表

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] devices = new int[n];
        for (int i = 0; i < n; i++) {
            devices[i] = scanner.nextInt();
        }
        int pMax = scanner.nextInt();

        Set<Integer> dp = new HashSet<>();
        dp.add(0);

        for (int p : devices) {
            Set<Integer> temp = new HashSet<>(dp);
            for (int preP : temp) {
                int curP = p + preP;
                if (curP <= pMax) {
                    dp.add(curP);
                }
            }
        }

        int maxPower = dp.stream().mapToInt(Integer::intValue).max().orElse(0);
        System.out.println(maxPower);
    }
}

cpp

2维DP数组

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;

    vector<int> devices(n);
    for (int i = 0; i < n; i++) {
        cin >> devices[i];
    }

    int pMax;
    cin >> pMax;

    vector<vector<bool>> dp(n + 1, vector<bool>(pMax + 1, false));
    dp[0][0] = true;

    for (int i = 1; i <= n; i++) {
        int p = devices[i - 1];
        for (int preP = 0; preP <= pMax; preP++) {
            if (dp[i - 1][preP]) {
                dp[i][preP] = true;
                int curP = p + preP;
                if (curP <= pMax) {
                    dp[i][curP] = true;
                }
            }
        }
    }

    int maxP = -1;
    for (int i = 0; i <= pMax; i++) {
        if (dp[n][i]) {
            maxP = i;
        }
    }

    cout << maxP << endl;

    return 0;
}

1维DP数组

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;

    vector<int> devices(n);
    for (int i = 0; i < n; i++) {
        cin >> devices[i];
    }

    int pMax;
    cin >> pMax;

    vector<bool> dp(pMax + 1, false);
    dp[0] = true;

    for (int p : devices) {
        vector<bool> temp = dp;
        for (int preP = 0; preP <= pMax; preP++) {
            if (temp[preP]) {
                int curP = p + preP;
                if (curP <= pMax) {
                    dp[curP] = true;
                }
            }
        }
    }

    int maxP = -1;
    for (int i = 0; i <= pMax; i++) {
        if (dp[i]) {
            maxP = i;
        }
    }

    cout << maxP << endl;

    return 0;
}

1维DP哈希表

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

using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> devices(n);
    for (int i = 0; i < n; i++) {
        cin >> devices[i];
    }
    int p_max;
    cin >> p_max;

    unordered_set<int> dp;
    dp.insert(0);

    for (int p : devices) {
        vector<int> temp(dp.begin(), dp.end());
        for (int pre_p : temp) {
            int cur_p = p + pre_p;
            if (cur_p <= p_max) {
                dp.insert(cur_p);
            }
        }
    }

    int maxPower = *max_element(dp.begin(), dp.end());
    cout << maxPower << endl;

    return 0;
}

时空复杂度

时间复杂度：O(``N*p_max``)。需要遍历N种不同功率的设备，每个设备都要考虑len(dp)种前置情况。

空间复杂度：O(``p_max``)。dp哈希集合最多储存p_max+1个元素。

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

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

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

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

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

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

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

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

闭着眼睛学算法
关注
  • 9
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
订阅专栏
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【模拟】2024D-灰度图恢复【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
04-26 1903
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DP】2024D-分披萨【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
08-09 894
可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DP】2024D-分月饼【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
07-15 1486
有LeetCode算法/华为OD考试扣扣交流群可加可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DP】2024D-抢7游戏【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
06-20 1268
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DP】2024D-园区参观路径【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
06-19 757
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DP】2024D-跳格子(3)【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
07-15 995
有LeetCode算法/华为OD考试扣扣交流群可加可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【回溯】2024D-表演赛游戏分组【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
04-22 1148
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1336了解算法冲刺训练。
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【单调栈】2024D-找最小数【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
08-09 378
可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
2024华为OD机考机试 真题目录（E卷 +C卷 + D卷 + B卷 + A卷） + 考点说明
热门推荐
算法大师，励志更新全网最全的算法题库！
03-18 36万+
OD，全称(Outsourcing Dispacth)模式，目前华为和德科联合招聘的简称。华为社招基本都是OD招聘，17级以下都是OD模式（13-17）。
华为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机考三道题的代码，以及考试过程中的一个记录
06-01
在“HuaWeiOD-master”文件夹中，每一道题目的代码可能是以单独的文件存在，命名可能为“Question1.py”、“Question2.java”等，对应不同的编程语言。代码文件通常会包含完整的解决问题的逻辑，包括输入处理、算法...
华为OD题分糖果猴子吃桃服务器广播和最大的子矩阵gpu耗时最大子矩阵和最大的字串计算字符串数量正方体翻面计算最短步长py3.9
08-23
华为OD题分糖果猴子吃桃服务器广播和最大的子矩阵gpu耗时最大子矩阵和最大的字串计算字符串数量正方体翻面计算最短步长py3.9
华为研发笔试题西安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 ...
JAVA进阶补充
2301_80150315的博客
08-15 1014
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 899
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1136
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
【Spring框架】
最新发布
m0_71941456的博客
08-18 836
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
华为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、付费专栏及课程。

余额充值