【最新华为OD机试E卷】日志采集系统(100分)

🍭 大家好这里是春秋招笔试突围 ，一枚热爱算法的程序员

💻 ACM金牌🏅️团队 ｜ 大厂实习经历 ｜ 多年算法竞赛经历

✨ 本系列打算持续跟新华为OD-E/D卷的多语言AC题解

👏 感谢大家的订阅➕ 和 喜欢💗 和手里的小花花🌸

最新华为OD机试E卷目录，全、新、准，题目覆盖率达 95% 以上，其中D卷题目全部支持在线评测，E卷题目敬请期待

最新华为OD机试目录: https://www.nowcoder.com/share/jump/3022116661724989756887

🎀关于华为OD

• ✨华为OD的概念 华为的大部分社会招聘采用了被称为OD（Outsourcing Dispatch）模式，这是一种与德科共同进行的招聘方式。在这种模式下，被招聘的员工通常被定级在13至17级，这些员工被视为华为的储备人才。华为每年会从这些OD项目中选拔表现出色的员工，并将他们转为正式员工。
• ⌚️华为 OD 应聘流程

  • 第一步：投递简历

    • 提供姓名、邮箱、手机号、身份证号，用于锁定，所以投递前需要考虑清楚，投到项目组之后，一般不会转给另一个项目的 HR 了，也就是被锁定。

  • 第二步：机试

    • 3 道算法题，400 分满分，一般 1 个月的准备时间，华为机试必须要 150 分以上，没有过半年之后才能参加下一次考试。

  • 第三步：技术面

    • 2 轮技术面试。

  • 第四步：HR 与主管面试

  • 第五步：录用，发 offer

🍓OJ题目截图

📝 日志采集系统

问题描述

日志采集是运维系统的核心组件。日志是按行生成，每行记做一条，由采集系统分批上报。

• 如果上报太频繁，会对服务端造成压力；
• 如果上报太晚，会降低用户的体验；
• 如果一次上报的条数太多，会导致超时失败。

为此，项目组设计了如下的上报策略：

1. 每成功上报一条日志，奖励 1 分。
2. 每条日志每延迟上报 1 秒，扣 1 分。
3. 积累日志达到 100 条，必须立即上报。

给出日志序列，根据该规则，计算首次上报能获得的最多积分数。

输入格式

一行空格分隔的整数 ，表示按时序产生的日志条数，其中 ，。

输出格式

一个整数，表示首次上报最多能获得的积分数。

样例输入 1

1 98 1

样例输出 1

98

样例解释 1

时刻上报得 1 分， 时刻上报得 98 分（最大）， 时刻上报得 0 分。

样例输入 2

50 60 1

样例输出 2

50

样例解释 2

如果第 1 个时刻上报，获得积分 50。如果第 2 个时刻上报，最多上报 100 条，前 50 条延迟上报 1s，每条扣除 1 分，共获得积分为 100-50=50。

样例输入 3

3 7 40 10 60

样例输出 3

37

样例解释 3

时刻上报得 3 分， 时刻上报得 7 分， 时刻上报得 37 分（最大）， 时刻上报得 -3 分， 时刻上报，因为已经超了 100 条限制，所以只能上报 100 条，得 -23 分。

数据范围

题解

动态规划

这道题目要求我们计算日志上报系统能获得的最大积分。

关键在于理解积分规则和找出最佳上报时机。

解题思路如下：

1. 遍历每个时间点，计算如果在该时间点上报能获得的积分。
2. 维护三个数组：
   • positive_scores：记录每个时间点累积的正向得分。
   • penalty_scores：记录每个时间点累积的延迟惩罚分。
   • final_scores：记录每个时间点的最终得分。
3. 对于每个时间点，更新这三个数组：
   • positive_scores[i] = min(100, positive_scores[i-1] + actions[i])：累加日志数，但不超过100。
   • penalty_scores[i] = penalty_scores[i-1] + positive_scores[i-1]：计算延迟惩罚。
   • final_scores[i] = positive_scores[i] - penalty_scores[i]：计算最终得分。
4. 如果累积日志数达到100，立即结束计算。
5. 返回 final_scores 中的最大值。

参考代码

• Python

def calculate_max_score(actions):
    total_actions = len(actions)
    
    # 初始化三个数组，用于记录不同类型的得分
    positive_scores = [0] * total_actions  # 正向得分数组
    penalty_scores = [0] * total_actions   # 累计延迟得分数组
    final_scores = [0] * total_actions     # 最终得分数组

    # 初始化第一个时间点的得分
    positive_scores[0] = actions[0]
    final_scores[0] = actions[0]

    # 遍历每个时间点，计算得分
    for time in range(1, total_actions):
        # 计算正向得分，但不超过100
        positive_scores[time] = min(100, positive_scores[time - 1] + actions[time])
        
        # 计算累计延迟得分
        penalty_scores[time] = penalty_scores[time - 1] + positive_scores[time - 1]
        
        # 计算最终得分
        final_scores[time] = positive_scores[time] - penalty_scores[time]

        # 如果累积日志数达到100，立即结束循环
        if positive_scores[time] >= 100:
            break

    # 返回最大得分
    return max(final_scores)

# 主函数
if __name__ == "__main__":
    # 从输入获取日志序列
    actions = list(map(int, input().split()))
    # 计算并输出最大得分
    print(calculate_max_score(actions))

• C

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

#define MAX_N 1000
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

int calculate_max_score(int actions[], int n) {
    int positive_scores[MAX_N] = {0};  // 正向得分数组
    int penalty_scores[MAX_N] = {0};   // 累计延迟得分数组
    int final_scores[MAX_N] = {0};     // 最终得分数组
    int max_score = 0;

    // 初始化第一个时间点的得分
    positive_scores[0] = actions[0];
    final_scores[0] = actions[0];
    max_score = actions[0];

    // 遍历每个时间点，计算得分
    for (int time = 1; time < n; time++) {
        // 计算正向得分，但不超过100
        positive_scores[time] = MIN(100, positive_scores[time - 1] + actions[time]);
        
        // 计算累计延迟得分
        penalty_scores[time] = penalty_scores[time - 1] + positive_scores[time