华为OD机试 - 星际篮球争霸赛 - 回溯（Python/JS/C/C++ 2024 E卷 200分）

于 2024-10-04 23:34:10 发布
阅读量658 收藏 7
点赞数 12
分类专栏： 搬砖工逆袭Java架构师 文章标签： 华为od python javascript
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/guorui_java/article/details/142702110
版权

在这里插入图片描述

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

在星球争霸篮球赛对抗赛中，最大的宇宙战队希望每个队员都能拿到 MVP。MVP的条件是单场最高得分得分者。

可以安排队列让宇宙战队决定在比赛中尽可能让更多队员上场，并且让所有得分的选手得分都相同，然而比赛过程中的每1分钟的得分都只能由某一个人包揽。

二、输入描述

输入第一行为一个数字 t，表示为有得分的分钟数 1 ≤ t ≤ 50
第二行为 t 个数字，代表每一分钟的得分 p，1 ≤ p ≤ 50

三、输出描述

输出所有得分的队员都是MVP时，最少得MVP得分。

四、测试用例

测试用例1：

1、输入

9
5 2 1 5 2 1 5 2 1

2、输出

6

3、说明

一共 4 人得分，分别都是 6 分。5+1，5+1，5+1，2+2+2

测试用例2：

1、输入

5
3 3 3 3 3

2、输出

3

3、说明

每个队员得分为3，共5个队员。

五、解题思路

1、问题分析

需要将每一分钟的得分分配给尽可能多的队员，使得所有队员的总得分相同，并且每个队员的得分都是MVP（即得分最高的队员）。换句话说，我们需要将所有得分分配给若干队员，使得每个队员的总得分相同，且这个总得分尽可能小。

2、排序优化

首先将得分数组按降序排序，这样可以优先分配较大的得分，减少回溯的深度，提高效率。

3、剪枝策略

如果当前得分大于目标得分 target，则直接跳过该 k。

在回溯过程中，如果某个队员已经尝试过某个得分但未成功，则跳过相同的情况，避免重复计算。

如果某个队员的得分为0，且当前得分无法分配给他，则后续队员也无法分配该得分，直接终止该分支。

4、具体步骤

  1. 计算总得分：首先计算所有得分的总和 sum。
  2. 尝试不同的队员数量：从最大的可能队员数量（即 t）开始，逐步减少，直到找到一个能够将总得分均匀分配给这些队员的数量 k。
  3. 验证可行性：
    • 检查 sum 是否能被 k 整除。如果不能，继续尝试下一个 k。
    • 如果可以，计算每个队员的目标得分 S = sum / k。
    • 使用回溯法尝试将所有得分分配给 k 个队员，使得每个队员的总得分恰好为 S。
  4. 确定最小的 MVP 得分：一旦找到满足条件的 k，对应的 S 就是所求的最小 MVP 得分。

六、Python算法源码

# Python版本的OdTest类
import sys
import sys
sys.setrecursionlimit(10000)  # 增加递归深度限制

def main():
    import sys
    from sys import stdin
    import sys

    # 读取输入
    t_and_scores = sys.stdin.read().split()
    t = int(t_and_scores[0])  # 读取得分的分钟数
    scores = list(map(int, t_and_scores[1:t+1]))  # 读取每一分钟的得分

    total_sum = sum(scores)  # 计算所有得分的总和

    scores.sort(reverse=True)  # 将得分按降序排序，优化回溯过程

    n = t  # 得分的分钟数

    # 定义回溯函数，尝试将得分分配到各个队员
    def can_partition(index, buckets, target):
        if index == n:
            return True  # 所有得分都已分配完毕
        current = scores[index]  # 当前要分配的得分
        for i in range(len(buckets)):
            if buckets[i] + current > target:
                continue  # 如果当前队员得分超过目标，跳过
            if i > 0 and buckets[i] == buckets[i-1]:
                continue  # 避免重复尝试
            buckets[i] += current  # 将当前得分分配给队员i
            if can_partition(index + 1, buckets, target):
                return True  # 如果成功分配，返回True
            buckets[i] -= current  # 回溯，撤销分配
            if buckets[i] == 0:
                break  # 如果当前队员得分为0，后续队员也不会分配到得分
        return False  # 无法成功分配

    # 从最大可能的队员数量开始尝试
    for k in range(n, 0, -1):
        if total_sum % k != 0:
            continue  # 如果总得分不能被k整除，跳过
        target = total_sum // k  # 每个队员的目标得分
        if scores[0] > target:
            continue  # 如果最大的单个得分大于目标得分，跳过
        buckets = [0] * k  # 初始化每个队员当前的得分
        if can_partition(0, buckets, target):
            print(target)  # 输出最小的 MVP 得分
            return

if __name__ == "__main__":
    main()

七、JavaScript算法源码

// JavaScript版本的OdTest类

const readline = require('readline');

// 创建接口读取输入
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let input = [];
rl.on('line', (line) => {
    input = input.concat(line.trim().split(' '));
}).on('close', () => {
    // 解析输入
    const t = parseInt(input[0]); // 读取得分的分钟数
    const scores = input.slice(1, t+1).map(Number); // 读取每一分钟的得分

    const totalSum = scores.reduce((a, b) => a + b, 0); // 计算所有得分的总和

    scores.sort((a, b) => b - a); // 将得分按降序排序，优化回溯过程

    const n = t; // 得分的分钟数

    // 定义回溯函数，尝试将得分分配到各个队员
    function canPartition(index, buckets, target) {
        if (index === n) {
            return true; // 所有得分都已分配完毕
        }
        const current = scores[index]; // 当前要分配的得分
        for (let i = 0; i < buckets.length; i++) {
            if (buckets[i] + current > target) {
                continue; // 如果当前队员得分超过目标，跳过
            }
            if (i > 0 && buckets[i] === buckets[i - 1]) {
                continue; // 避免重复尝试
            }
            buckets[i] += current; // 将当前得分分配给队员i
            if (canPartition(index + 1, buckets, target)) {
                return true; // 如果成功分配，返回True
            }
            buckets[i] -= current; // 回溯，撤销分配
            if (buckets[i] === 0) {
                break; // 如果当前队员得分为0，后续队员也不会分配到得分
            }
        }
        return false; // 无法成功分配
    }

    // 从最大可能的队员数量开始尝试
    for (let k = n; k >=1; k--) {
        if (totalSum % k !== 0) {
            continue; // 如果总得分不能被k整除，跳过
        }
        const target = Math.floor(totalSum / k); // 每个队员的目标得分
        if (scores[0] > target) {
            continue; // 如果最大的单个得分大于目标得分，跳过
        }
        const buckets = Array(k).fill(0); // 初始化每个队员当前的得分
        if (canPartition(0, buckets, target)) {
            console.log(target); // 输出最小的 MVP 得分
            process.exit(0);
        }
    }
});

八、C算法源码

// C语言版本的OdTest类

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// 全局变量存储得分和其他参数
int scores[50];
int n;
int totalSum;

// 比较函数，用于降序排序
int compare(const void* a, const void* b) {
    return (*(int*)b - *(int*)a);
}

// 回溯函数，尝试将得分分配到各个队员
bool canPartition(int index, int buckets[], int k, int target) {
    if (index == n) {
        return true; // 所有得分都已分配完毕
    }
    int current = scores[index]; // 当前要分配的得分
    for (int i = 0; i < k; i++) {
        if (buckets[i] + current > target) {
            continue; // 如果当前队员得分超过目标，跳过
        }
        if (i > 0 && buckets[i] == buckets[i-1]) {
            continue; // 避免重复尝试
        }
        buckets[i] += current; // 将当前得分分配给队员i
        if (canPartition(index + 1, buckets, k, target)) {
            return true; // 如果成功分配，返回True
        }
        buckets[i] -= current; // 回溯，撤销分配
        if (buckets[i] == 0) {
            break; // 如果当前队员得分为0，后续队员也不会分配到得分
        }
    }
    return false; // 无法成功分配
}

int main(){
    // 读取输入
    scanf("%d", &n); // 读取得分的分钟数
    for(int i =0; i < n; i++){
        scanf("%d", &scores[i]); // 读取每一分钟的得分
        totalSum += scores[i]; // 计算总得分
    }

    // 将得分按降序排序，优化回溯过程
    qsort(scores, n, sizeof(int), compare);

    // 从最大可能的队员数量开始尝试
    for(int k = n; k >=1; k--){
        if(totalSum % k != 0){
            continue; // 如果总得分不能被k整除，跳过
        }
        int target = totalSum / k; // 每个队员的目标得分
        if(scores[0] > target){
            continue; // 如果最大的单个得分大于目标得分，跳过
        }
        int* buckets = (int*)calloc(k, sizeof(int)); // 初始化每个队员当前的得分
        if(canPartition(0, buckets, k, target)){
            printf("%d\n", target); // 输出最小的 MVP 得分
            free(buckets);
            return 0;
        }
        free(buckets);
    }
    return 0;
}

九、C++算法源码

// C++版本的OdTest类

#include <bits/stdc++.h>
using namespace std;

int main(){
    int n;
    cin >> n; // 读取得分的分钟数
    vector<int> scores(n);
    int totalSum =0;
    for(int &x: scores){
        cin >> x; // 读取每一分钟的得分
        totalSum += x; // 计算总得分
    }

    sort(scores.begin(), scores.end(), greater<int>()); // 将得分按降序排序，优化回溯过程

    // 定义回溯函数，尝试将得分分配到各个队员
    function<bool(int, vector<int>&, int)> canPartition = [&](int index, vector<int> &buckets, int target) -> bool {
        if(index == n){
            return true; // 所有得分都已分配完毕
        }
        int current = scores[index]; // 当前要分配的得分
        for(int i=0; i < buckets.size(); i++){
            if(buckets[i] + current > target){
                continue; // 如果当前队员得分超过目标，跳过
            }
            if(i >0 && buckets[i] == buckets[i-1]){
                continue; // 避免重复尝试
            }
            buckets[i] += current; // 将当前得分分配给队员i
            if(canPartition(index +1, buckets, target)){
                return true; // 如果成功分配，返回True
            }
            buckets[i] -= current; // 回溯，撤销分配
            if(buckets[i] ==0){
                break; // 如果当前队员得分为0，后续队员也不会分配到得分
            }
        }
        return false; // 无法成功分配
    };

    // 从最大可能的队员数量开始尝试
    for(int k = n; k >=1; k--){
        if(totalSum % k !=0){
            continue; // 如果总得分不能被k整除，跳过
        }
        int target = totalSum / k; // 每个队员的目标得分
        if(scores[0] > target){
            continue; // 如果最大的单个得分大于目标得分，跳过
        }
        vector<int> buckets(k, 0); // 初始化每个队员当前的得分
        if(canPartition(0, buckets, target)){
            cout << target << endl; // 输出最小的 MVP 得分
            return 0;
        }
    }
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

在这里插入图片描述

哪 吒
关注
专栏目录
webpack打包会根据webp-loader生成webp格式图片
weikehang的博客
11-11 1917
/*** * create by porter * 这个loader已经包含了url-loader file-loader * webp的 * 参数：options{ * name:[name].[hash].[ext] 不传则默认使用hash 这个是url|file|webp * preset 文件类型 default，photo，picture，drawing，icon和...
webpack解惑：require的五种用法
aigenglong0649的博客
10-12 1026
我之前在《前端搭环境之从入门到放弃》这篇文章中吐槽过，webpack中可以写commonjs格式的require同步语法，可以写AMD格式的require回调语法，还有一个require.ensure，以及webpack自己定义的require.include，再加上ES6的import语法，这么多岂不是会把人给搞乱。本篇就来梳理一下这些require各自的特点，以及都在什么场景下使用...
webpack的基础
c_l_a_n_n_d的博客
11-23 196
webpack 是一个用于现代 JavaScript 应用程序的 静态模块打包工具。当 webpack 处理应用程序时，它会在内部从一个或多个入口点构建一个 依赖图(dependency graph)，然后将你项目中所需的每一个模块组合成一个或多个 bundles，它们均为静态资源，用于展示你的内容。
webpack5打包工具的使用
weixin_43526403的博客
02-20 2314
webpack打包工具的使用
vue.config.js配置打包之类操作 webpack（压缩js，css,图片）
shi19970609的博客
12-28 2114
// vue.config.js的基础配置 const path = require('path') const CompressionPlugin = require('compression-webpack-plugin') //js css 压缩 const productionGzipExtensions = ["js", "css", 'scss']; // 需要gzip压缩的文件后缀 const merge = require("lodash.merge"); //对象合并插件 const U.
前端10年进化 Node.js、模块化、CommonJS、AMD、CMD、Webpack、Vue-cli、Electron-vue
王森的博客
06-24 962
我们从模块化开始，了解了模块化的概念和不同模块化方案（如 AMD、CMD 和 ES6 模块）。然后，我们探讨了前端构建工具 webpack 的基本原理、打包优化和配置技巧。我们还涉及了 babel 的作用和使用方法，以及在 Vue.js 和 Electron 中的配置。此外，我们还讨论了预编译和编译的概念，以及不同语言中的应用。最后，我们深入了解了 Electron-vue 的目录结构、配置文件和多窗口开发。通过适当的配置和调整，我们可以根据项目需求优化目录结构、打包方式和模块化开发，以实现更好的开发体验和
webpack5搭建vue环境
qq_28501393的博客
11-11 932
webpack5搭建vue环境
webpack自定义插件plugin 过程
weixin_38222276的博客
06-16 170
const fs=require(‘fs’) const readFileAsync=require(‘util’).promisify(fs.readFile) //异步读取文件 const writeFileAsync=require(‘util’).promisify(fs.writeFile)//异步写文件 class StaticChage{ // apply 是固定写法，自动执行 apply(complier){ // complier.hooks 中包含一些钩子函数 // emit 编译完成还
Webpack 性能优化方案看这篇就够了！
LuckyWinty的博客
09-18 587
点击上方前端Q，关注公众号回复加群，加入前端Q技术交流群无论在面试还是内部晋升，性能优化方案 一直都是非常重要的部分。性能优化可以分为很多种，比如：打包工具（webpack || vite）性能优化访问速度优化用户感知优化代码标准化...正文在了解 webpack 的性能优化之前，我们需要先对性能优化有一个总体的认知，总共分为 3 点：在业务开发中，不要过早的考虑性能优化，而且业务开发大部分时候...
webpack初识
weixin_37989623的博客
09-17 235
本文主要讨论webpack4的基础配置信息。 webpack是什么？ webpack可识别ES6 module模块引入方式(import引入语句)、CommonJs模块或者AMD、CMD等，即是一个模块打包工具，可以识别任何模块引入的语法，是基于node.js开发的模块打包工具，本质上是由node实现的。 本质上，webpack是一个现代JavaScript应用程序的静态模块打包器(module bundler)。当 webpack 处理应用程序时，它会递归地构建一个依赖关系图(dependency gr
详解webpack分包及异步加载套路
01-19
最近一个小项目是用webpack来进行构建的。... var path = require('path'), DashboardPlugin = require('webpack-dashboard/plugin'), HtmlWebpackPlugin = require('html-webpack-plugin'), webpack = requ
webpack是如何实现模块化加载的方法
01-19
webpack支持的模块规范有 AMD 、CommonJS、ES2015 import 等规范。不管何种规范大致可以分为同步加载和异步加载两种情况。本文将介绍webpack是如何实现模块管理和加载。 同步加载如下： import a from './a'; ...
详解webpack解惑：require的五种用法
01-21
webpack中可以写commonjs格式的require同步语法，可以写AMD格式的require回调语法，还有一个require.ensure，以及webpack自己定义的require.include，再加上ES6的import语法，这么多岂不是会把人给搞乱。本篇就来...
详解webpack require.ensure与require AMD的区别
11-29
在JavaScript的世界里，模块加载是实现代码组织和优化的关键部分。两种常见的模块加载方式是AMD (Asynchronous Module Definition) 和 webpack 的 `require.ensure`。本文将深入探讨它们之间的差异。 首先，我们来...
webpack学习笔记之代码分割和按需加载的实例详解
12-01
在 Webpack 中，实现代码分割和按需加载可以使用 `require.ensure` 或 `import()` 语法。`require.ensure` 是 Webpack 特有的，用于在打包时生成独立的 chunk，并在运行时异步加载。`import()` 是 ES 模块的动态导入...
引入Scrum激发研发体系活力
tonyli288的专栏
09-27 1234
确保团队成员具备必要的技能和协作能力，并保持团队的稳定性，以便于持续改进和高效运作，选择合适的团队成员至关重要。可以通过邀请外部专家授课、内部研讨会等形式，确保全员都能理解和接受这一新的工作方式，提升团队成员对Scrum的认知，并通过宣导活动，营造支持敏捷转型的企业氛围。Scrum的增量式交付和频繁的反馈循环，使得团队能够快速调整方向，响应市场变化和客户需求，提高产品的市场竞争力。Scrum通过明确的角色分工和固定的迭代周期，帮助团队更好地规划和管理工作，减少浪费和瓶颈，提高整体研发效率。
敏感字段加密 - 华为OD统一考试(E卷)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
09-27 824
敏感字段加密 - 华为OD统一考试(E卷) 【敏感字段加密】给定一个由多个命令字组成的命令字符串: 1、字符串长度小于等于127字节，只包含大小写字母，数字，下划线和偶数个双引号; 2、命令字之间以一个或多个下划线 进行分割; 3、可以通过两个双引号""来标识包含下划线 的命令字或空命令字(仅包含两个双引号的命令字)，双引号不会在命令字内部出现;请对指定索引的敏感字段进行加密，替换为`******`(6个*)，并删除命令字前后多余的下划线_。如果无法找到指定索引的命令字，输出字符串ERROR.
编码能力提升计划 - 华为OD统一考试(E卷)
最新发布
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
10-01 492
编码能力提升计划 - 华为OD统一考试(E卷) 为了提升软件编码能力，小王制定了刷题计划，他选了题库中的n道题，编号从0到n-1，并计划在m天内按照题目编号顺序刷完所有的题目(注意，小王不能用多天完成同一题)。 在小王刷题计划中，小王需要用 `time[i]` 的时间完成编号 `i`的题目。此外，小王还可以查看答案，可以省去该题的做题时间。为了真正达到刷题效果，小王每天最多直接看一次答案。 我们定义m天中做题时间最多的一天耗时为T(直接看答案的题目不计入做题总时间)。请你帮小王求出最小的T是多少。
报数游戏 - 华为OD统一考试(E卷)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
09-28 641
报数游戏 - 华为OD统一考试(E卷) 100个人围成一圈，每个人有一个编号，编号从1开始到100。他们从1开始依次报数，报到为M的人自动退出圈圈，然后下一个人接着从1开始报数，直到剩余的人数小于M。请问最后剩余的人在原先的编号为多少？
华为od机试 - 英文输入法c语言
02-07
华为od机试 - 英文输入法c语言 华为od机试是华为公司面向程序员的一种招聘方式，要求应聘者使用c语言编程解决相关问题。在这个机试中，可能会涉及到使用英文输入法来编写c语言代码。 英文输入法是一种能够输入英文字符的输入方式，能够帮助程序员在使用英文编程语言时快速输入代码。在c语言编程中，使用英文输入法可以更方便地编写各种语法结构和关键字，比如if、while、for等等。此外，英文输入法也能够更准确地输入各种特殊符号和运算符，比如加号、减号、括号等，这些都是c语言中经常用到的符号，能够提高程序员的编码效率。 在华为od机试中，应聘者可能会遇到需要使用英文输入法编写c语言代码的题目，这需要应聘者具备良好的英文输入法技能，能够快速准确地输入英文字符和特殊符号，确保代码的正常编写和运行。因此，熟练掌握英文输入法对于参加华为od机试的程序员来说是非常重要的。 总之，在华为od机试中，使用英文输入法编写c语言代码是常见的要求，要求应聘者具备良好的英文输入法技能，能够高效地完成编程任务。这也体现了华为对于程序员的基本技能和能力的要求，希望应聘者能够在机试中充分展现自己的专业水平和编程能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哪 吒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值