可上 欧弟OJ系统 练习华子OD、大厂真题
绿色聊天软件戳od1441
了解算法冲刺训练(备注【CSDN】否则不通过)
文章目录
相关推荐阅读
- 【华为OD机考】2024D+E卷最全真题【完全原创题解 | 详细考点分类 | 不断更新题目】
- 【华为OD笔试】2024D+E卷机考套题汇总【真实反馈,不断更新,限时免费】
- 【华为OD笔试】2024D卷命题规律解读【分析300+场OD笔试考点总结】
从2024年8月14号开始,OD机考全部配置为2024E卷。
注意几个关键点:
- 大部分的题目仍为往期2023A+B+C以及2024D的旧题。注意万变不离其宗,把方法掌握,无论遇到什么题目都可以轻松应对。
- 支持多次提交题目,以最后一次提交为准。可以先做200的再做100的,然后可以反复提交。
- E卷仍然为单机位+屏幕监控的形式进行监考。
- 进入考试界面新加入了这样一段话并且用红字标出,可以看出华子对作弊代考等行为是0容忍的,请各位同学认真学习,不要妄图通过其他违规途径通过考试。
题目描述与示例
题目描述
某个充电站,可提供n
个充电设备,每个充电设备均有对应的输出功率。
任意个充电设备组合的输出功率总和,均构成功率集合P
的一个元素。
功率集合P
的最优元素,表示最接近充电站最大输出功率p_max
的元素。
输入描述
输入为3
行:
第一行:充电设备个数n
第二行:每个充电设备的输出功率
第三行:充电站最大输出功率p_max
输出描述
功率集合P
的最优元素
补充说明:
- 充电设备个数
n`` ``>`` ``0
- 最优元素必须小于或等于充电站最大输出功率
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
了解更多