【2024年华为OD机试】 (C卷,100分)- 用户调度问题（JavaScriptJava PythonC/C++）

在这里插入图片描述

一、问题描述

问题描述

在通信系统中，有 n 个待串行调度的用户，每个用户可以选择 A、B、C 三种调度策略。不同的策略会消耗不同的系统资源。调度规则如下：

  1. 相邻用户不能使用相同的调度策略：例如，如果第 1 个用户选择了 A 策略，则第 2 个用户只能选择 B 或 C 策略。
  2. 局部最优选择：每个用户依次选择当前所能选择的对系统资源消耗最少的策略（局部最优）。如果有多个满足要求的策略，则选择最后一个。

目标是找到满足上述规则的最优策略组合，并返回总的系统资源消耗数。

输入描述

  • 第一行表示用户个数 n。
  • 接下来的 n 行，每行表示一个用户分别使用 A、B、C 三种策略的系统消耗值（resA、resB、resC）。

输出描述

  • 返回最优策略组合下的总的系统资源消耗数。

用例

输入

3
15 8 17
12 20 9
11 7 5

输出

24

说明

  1. 第 1 个用户选择 B 策略，消耗为 8。
  2. 第 2 个用户不能选择 B 策略（与第 1 个用户相同），因此选择 C 策略，消耗为 9。
  3. 第 3 个用户不能选择 C 策略（与第 2 个用户相同），因此选择 B 策略，消耗为 7。
  4. 总消耗为 8 + 9 + 7 = 24。

题目解析

1. 问题分析

  • 每个用户有 3 种策略可选，但受限于相邻用户不能选择相同策略。
  • 每个用户需要选择当前局部最优的策略（消耗最少），如果有多个满足条件的策略，则选择最后一个。
  • 目标是计算满足规则的总消耗。

2. 局部最优条件

  • 局部最优：每个用户在选择策略时，只考虑当前可选的策略中消耗最小的一个。
  • 选择规则：
    • 如果当前用户有多个可选策略的消耗相同，则选择最后一个（即优先级最低的策略）。
    • 例如，如果可选策略为 A 和 B，且 resA = resB，则选择 B。

3. 解题思路

  1. 初始化：

    • 从第 1 个用户开始，选择消耗最小的策略。
    • 记录当前用户选择的策略类型（A、B 或 C）。

  2. 遍历用户：

    • 对于第 i 个用户，根据第 i-1 个用户选择的策略类型，排除相同策略。
    • 在剩余可选策略中，选择消耗最小的策略。
    • 如果有多个可选策略的消耗相同，则选择最后一个。

  3. 计算总消耗：

    • 将每个用户选择的策略消耗累加，得到总消耗。

示例解析

输入

3
15 8 17
12 20 9
11 7 5

步骤

  1. 第 1 个用户：

    • 可选策略：A、B、C。
    • 消耗值：15、8、17。
    • 选择消耗最小的策略 B，消耗为 8。

  2. 第 2 个用户：

    • 不能选择 B 策略（与第 1 个用户相同）。
    • 可选策略：A、C。
    • 消耗值：12、9。
    • 选择消耗最小的策略 C，消耗为 9。

  3. 第 3 个用户：

    • 不能选择 C 策略（与第 2 个用户相同）。
    • 可选策略：A、B。
    • 消耗值：11、7。
    • 选择消耗最小的策略 B，消耗为 7。

  4. 总消耗：

    • 8 + 9 + 7 = 24。

总结

  • 本题的核心是局部最优选择，每个用户只需在当前可选策略中选择消耗最小的一个。
  • 通过遍历用户并动态排除相邻用户的相同策略，可以高效地计算出最优策略组合的总消耗。
  • 题目难度较低，适合理解贪心算法的基本思想。

二、JavaScript算法源码

以下是代码的详细注释和讲解：

代码结构

这段代码的目的是根据题目规则，计算用户调度策略的最优总消耗。代码分为以下几个部分：

  1. 输入处理：从控制台读取输入数据，包括用户数量 n 和每个用户的策略消耗值。
  2. 主逻辑函数：遍历每个用户，选择局部最优策略，并计算总消耗。
  3. 辅助函数：用于找到当前用户可选策略中消耗最小的策略索引。

代码逐行解析

1. 输入处理
const readline = require("readline");const rl = readline.createInterface({input: process.stdin,output: process.stdout,
});const lines = [];
let n;
rl.on("line", (line) => {lines.push(line);if (lines.length === 1) {n = parseInt(lines[0]);}if (n != undefined && lines.length === n + 1) {lines.shift();const res = lines.map((line) => line.split(" ").map(Number));console.log(getResult(n, res));lines.length = 0;}
});
  • readline 模块：用于从控制台逐行读取输入。
  • lines 数组：存储每一行的输入数据。
  • n：用户总数，从第一行输入中获取。
  • rl.on("line", ...)：监听输入事件，逐行读取数据。
    • 当读取到第一行时，解析出用户总数 n。
    • 当读取到 n + 1 行时（包括第一行），表示输入完成。
    • 从 lines 中提取每个用户的策略消耗值，并调用 getResult 函数计算结果。
    • 清空 lines 数组，以便处理下一组输入。
2. 主逻辑函数
function getResult(n, res) {let last = -1;let sum = 0;for (let i = 0; i < n; i++) {last = getMinEleIdx(res[i], last);sum += res[i][last];}return sum;
}
  • getResult 函数：主逻辑函数，计算最优策略组合的总消耗。
    • last：记录上一个用户选择的策略索引，初始值为 -1（表示没有限制）。
    • sum：记录总消耗，初始值为 0。
    • 遍历每个用户：
      • 调用 getMinEleIdx 函数，找到当前用户可选策略中消耗最小的策略索引。
      • 将选择的策略消耗累加到 sum 中。
    • 返回总消耗 sum。
3. 辅助函数
function getMinEleIdx(arr, excludeIdx) {let minEleVal = Infinity;let minEleIdx = -1;for (let i = 0; i < arr.length; i++) {if (i == excludeIdx) continue;if (arr[i] <= minEleVal) {minEleVal = arr[i];minEleIdx = i;}}return minEleIdx;
}
  • getMinEleIdx 函数：找到当前用户可选策略中消耗最小的策略索引。
    • arr：当前用户的策略消耗数组。
    • excludeIdx：需要排除的策略索引（即上一个用户选择的策略索引）。
    • minEleVal：记录当前最小消耗值，初始值为 Infinity。
    • minEleIdx：记录当前最小消耗值的索引，初始值为 -1。
    • 遍历策略消耗数组：
      • 如果当前索引等于 excludeIdx，则跳过（排除相邻用户相同策略）。
      • 如果当前策略消耗小于等于 minEleVal，则更新 minEleVal 和 minEleIdx。
    • 返回最小消耗值的索引 minEleIdx。

代码执行流程

  1. 输入阶段：

    • 读取用户总数 n。
    • 读取每个用户的策略消耗值，并存储在 res 数组中。

  2. 计算阶段：

    • 调用 getResult 函数，传入 n 和 res。
    • 遍历每个用户，选择局部最优策略，并累加总消耗。

  3. 输出阶段：

    • 输出最优策略组合的总消耗。

示例运行

输入
3
15 8 17
12 20 9
11 7 5
执行过程：
  1. 读取 n = 3。
  2. 读取策略消耗值：
    [[15, 8, 17],[12, 20, 9],[11, 7, 5]
]
  3. 调用 getResult(n, res)：
    • 第 1 个用户：
      • 可选策略：A、B、C。
      • 消耗值：15、8、17。
      • 选择消耗最小的策略 B，索引为 1，消耗为 8。
    • 第 2 个用户：
      • 不能选择 B 策略（与第 1 个用户相同）。
      • 可选策略：A、C。
      • 消耗值：12、9。
      • 选择消耗最小的策略 C，索引为 2，消耗为 9。
    • 第 3 个用户：
      • 不能选择 C 策略（与第 2 个用户相同）。
      • 可选策略：A、B。
      • 消耗值：11、7。
      • 选择消耗最小的策略 B，索引为 1，消耗为 7。
    • 总消耗：8 + 9 + 7 = 24。
  4. 输出 24。

总结

  • 代码通过局部最优选择规则，高效地计算了用户调度策略的最优总消耗。
  • 使用 getMinEleIdx 函数动态排除相邻用户的相同策略，确保选择符合规则的最小消耗策略。
  • 代码逻辑清晰，注释详细，适合理解和学习贪心算法的应用。

三、Java算法源码

以下是代码的详细注释和讲解：

代码结构

这段代码的目的是根据题目规则，计算用户调度策略的最优总消耗。代码分为以下几个部分：

  1. 输入处理：从控制台读取输入数据，包括用户数量 n 和每个用户的策略消耗值。
  2. 主逻辑函数：遍历每个用户，选择局部最优策略，并计算总消耗。
  3. 辅助函数：用于找到当前用户可选策略中消耗最小的策略索引。

代码逐行解析

1. 输入处理
import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int n = sc.nextInt();int[][] res = new int[n][3];for (int i = 0; i < n; i++) {res[i][0] = sc.nextInt();res[i][1] = sc.nextInt();res[i][2] = sc.nextInt();}System.out.println(getResult(n, res));}
}
  • Scanner 类：用于从控制台读取输入。
  • n：用户总数，从第一行输入中获取。
  • res 数组：存储每个用户的策略消耗值，大小为 n x 3。
    • res[i][0] 表示第 i 个用户选择 A 策略的消耗。
    • res[i][1] 表示第 i 个用户选择 B 策略的消耗。
    • res[i][2] 表示第 i 个用户选择 C 策略的消耗。
  • 读取输入：
    • 使用 sc.nextInt() 读取每个用户的策略消耗值。
  • 调用主逻辑函数：
    • 调用 getResult 函数，传入 n 和 res，并输出结果。
2. 主逻辑函数
public static int getResult(int n, int[][] res) {int last = -1;int sum = 0;for (int i = 0; i < n; i++) {last = getMinEleIdx(res[i], last);sum += res[i][last];}return sum;
}
  • getResult 函数：主逻辑函数，计算最优策略组合的总消耗。
    • last：记录上一个用户选择的策略索引，初始值为 -1（表示没有限制）。
    • sum：记录总消耗，初始值为 0。
    • 遍历每个用户：
      • 调用 getMinEleIdx 函数，找到当前用户可选策略中消耗最小的策略索引。
      • 将选择的策略消耗累加到 sum 中。
    • 返回总消耗 sum。
3. 辅助函数
public static int getMinEleIdx(int[] arr, int excludeIdx) {int minEleVal = Integer.MAX_VALUE;int minEleIdx = -1;for (int i = 0; i < arr.length; i++) {if (i == excludeIdx) continue;if (arr[i] <= minEleVal) {minEleVal = arr[i];minEleIdx = i;}}return minEleIdx;
}
  • getMinEleIdx 函数：找到当前用户可选策略中消耗最小的策略索引。
    • arr：当前用户的策略消耗数组。
    • excludeIdx：需要排除的策略索引（即上一个用户选择的策略索引）。
    • minEleVal：记录当前最小消耗值，初始值为 Integer.MAX_VALUE。
    • minEleIdx：记录当前最小消耗值的索引，初始值为 -1。
    • 遍历策略消耗数组：
      • 如果当前索引等于 excludeIdx，则跳过（排除相邻用户相同策略）。
      • 如果当前策略消耗小于等于 minEleVal，则更新 minEleVal 和 minEleIdx。
    • 返回最小消耗值的索引 minEleIdx。

代码执行流程

  1. 输入阶段：

    • 读取用户总数 n。
    • 读取每个用户的策略消耗值，并存储在 res 数组中。

  2. 计算阶段：

    • 调用 getResult 函数，传入 n 和 res。
    • 遍历每个用户，选择局部最优策略，并累加总消耗。

  3. 输出阶段：

    • 输出最优策略组合的总消耗。

示例运行

输入
3
15 8 17
12 20 9
11 7 5
执行过程：
  1. 读取 n = 3。
  2. 读取策略消耗值：
    [[15, 8, 17],[12, 20, 9],[11, 7, 5]
]
  3. 调用 getResult(n, res)：
    • 第 1 个用户：
      • 可选策略：A、B、C。
      • 消耗值：15、8、17。
      • 选择消耗最小的策略 B，索引为 1，消耗为 8。
    • 第 2 个用户：
      • 不能选择 B 策略（与第 1 个用户相同）。
      • 可选策略：A、C。
      • 消耗值：12、9。
      • 选择消耗最小的策略 C，索引为 2，消耗为 9。
    • 第 3 个用户：
      • 不能选择 C 策略（与第 2 个用户相同）。
      • 可选策略：A、B。
      • 消耗值：11、7。
      • 选择消耗最小的策略 B，索引为 1，消耗为 7。
    • 总消耗：8 + 9 + 7 = 24。
  4. 输出 24。

总结

  • 代码通过局部最优选择规则，高效地计算了用户调度策略的最优总消耗。
  • 使用 getMinEleIdx 函数动态排除相邻用户的相同策略，确保选择符合规则的最小消耗策略。
  • 代码逻辑清晰，注释详细，适合理解和学习贪心算法的应用。

四、Python算法源码

以下是代码的详细注释和讲解：

代码结构

这段代码的目的是根据题目规则，计算用户调度策略的最优总消耗。代码分为以下几个部分：

  1. 输入处理：从控制台读取输入数据，包括用户数量 n 和每个用户的策略消耗值。
  2. 辅助函数：用于找到当前用户可选策略中消耗最小的策略索引。
  3. 主逻辑函数：遍历每个用户，选择局部最优策略，并计算总消耗。
  4. 输出结果：调用主逻辑函数并输出结果。

代码逐行解析

1. 输入处理
import sys# 读取用户总数 n
n = int(input())# 读取每个用户的策略消耗值
res = [list(map(int, input().split())) for _ in range(n)]
  • sys 模块：用于引入 sys.maxsize，表示一个足够大的整数。
  • n：用户总数，从第一行输入中获取。
  • res 列表：存储每个用户的策略消耗值，大小为 n x 3。
    • res[i][0] 表示第 i 个用户选择 A 策略的消耗。
    • res[i][1] 表示第 i 个用户选择 B 策略的消耗。
    • res[i][2] 表示第 i 个用户选择 C 策略的消耗。
  • 读取输入：
    • 使用 input() 读取每行输入，并将其转换为整数列表。
2. 辅助函数
def getMinEleIdx(arr, excludeIdx):minEleVal = sys.maxsizeminEleIdx = -1for i in range(len(arr)):if i == excludeIdx:continueif arr[i] <= minEleVal:minEleVal = arr[i]minEleIdx = ireturn minEleIdx
  • getMinEleIdx 函数：找到当前用户可选策略中消耗最小的策略索引。
    • arr：当前用户的策略消耗数组。
    • excludeIdx：需要排除的策略索引（即上一个用户选择的策略索引）。
    • minEleVal：记录当前最小消耗值，初始值为 sys.maxsize（表示一个足够大的整数）。
    • minEleIdx：记录当前最小消耗值的索引，初始值为 -1。
    • 遍历策略消耗数组：
      • 如果当前索引等于 excludeIdx，则跳过（排除相邻用户相同策略）。
      • 如果当前策略消耗小于等于 minEleVal，则更新 minEleVal 和 minEleIdx。
    • 返回最小消耗值的索引 minEleIdx。
3. 主逻辑函数
def getResult():last = -1total = 0for i in range(n):last = getMinEleIdx(res[i], last)total += res[i][last]return total
  • getResult 函数：主逻辑函数，计算最优策略组合的总消耗。
    • last：记录上一个用户选择的策略索引，初始值为 -1（表示没有限制）。
    • total：记录总消耗，初始值为 0。
    • 遍历每个用户：
      • 调用 getMinEleIdx 函数，找到当前用户可选策略中消耗最小的策略索引。
      • 将选择的策略消耗累加到 total 中。
    • 返回总消耗 total。
4. 输出结果
# 调用主逻辑函数并输出结果
print(getResult())
  • 调用 getResult 函数，计算最优策略组合的总消耗，并输出结果。

代码执行流程

  1. 输入阶段：

    • 读取用户总数 n。
    • 读取每个用户的策略消耗值，并存储在 res 列表中。

  2. 计算阶段：

    • 调用 getResult 函数。
    • 遍历每个用户，选择局部最优策略，并累加总消耗。

  3. 输出阶段：

    • 输出最优策略组合的总消耗。

示例运行

输入
3
15 8 17
12 20 9
11 7 5
执行过程：
  1. 读取 n = 3。
  2. 读取策略消耗值：
    [[15, 8, 17],[12, 20, 9],[11, 7, 5]
]
  3. 调用 getResult()：
    • 第 1 个用户：
      • 可选策略：A、B、C。
      • 消耗值：15、8、17。
      • 选择消耗最小的策略 B，索引为 1，消耗为 8。
    • 第 2 个用户：
      • 不能选择 B 策略（与第 1 个用户相同）。
      • 可选策略：A、C。
      • 消耗值：12、9。
      • 选择消耗最小的策略 C，索引为 2，消耗为 9。
    • 第 3 个用户：
      • 不能选择 C 策略（与第 2 个用户相同）。
      • 可选策略：A、B。
      • 消耗值：11、7。
      • 选择消耗最小的策略 B，索引为 1，消耗为 7。
    • 总消耗：8 + 9 + 7 = 24。
  4. 输出 24。

总结

  • 代码通过局部最优选择规则，高效地计算了用户调度策略的最优总消耗。
  • 使用 getMinEleIdx 函数动态排除相邻用户的相同策略，确保选择符合规则的最小消耗策略。
  • 代码逻辑清晰，注释详细，适合理解和学习贪心算法的应用。

五、C/C++算法源码：

以下是 C++ 和 C语言 版本的代码实现，附带详细的中文注释和讲解。

C++ 版本

代码实现

#include <iostream>
#include <climits> // 用于引入 INT_MAX
using namespace std;// 辅助函数：找到当前用户可选策略中消耗最小的策略索引
int getMinEleIdx(int arr[], int arr_size, int excludeIdx) {int minEleVal = INT_MAX; // 初始化最小消耗值为最大整数int minEleIdx = -1;      // 初始化最小消耗值的索引为 -1// 遍历策略消耗数组for (int i = 0; i < arr_size; i++) {if (i == excludeIdx) continue; // 排除相邻用户相同策略// 如果当前策略消耗小于等于最小消耗值，则更新最小消耗值和索引if (arr[i] <= minEleVal) {minEleVal = arr[i];minEleIdx = i;}}return minEleIdx; // 返回最小消耗值的索引
}// 主逻辑函数：计算最优策略组合的总消耗
int getResult(int n, int res[][3]) {int last = -1; // 记录上一个用户选择的策略索引，初始值为 -1（表示没有限制）int sum = 0;   // 记录总消耗，初始值为 0// 遍历每个用户for (int i = 0; i < n; i++) {// 找到当前用户可选策略中消耗最小的策略索引last = getMinEleIdx(res[i], 3, last);// 将选择的策略消耗累加到总消耗中sum += res[i][last];}return sum; // 返回总消耗
}int main() {int n;cin >> n; // 读取用户总数 nint res[n][3]; // 定义二维数组存储每个用户的策略消耗值for (int i = 0; i < n; i++) {cin >> res[i][0] >> res[i][1] >> res[i][2]; // 读取每个用户的策略消耗值}// 调用主逻辑函数并输出结果cout << getResult(n, res) << endl;return 0;
}

代码讲解

  1. 输入处理：

    • 使用 cin 从控制台读取用户总数 n。
    • 定义二维数组 res，大小为 n x 3，用于存储每个用户的策略消耗值。
    • 使用 cin 读取每个用户的策略消耗值。

  2. 辅助函数 getMinEleIdx：

    • 找到当前用户可选策略中消耗最小的策略索引。
    • 排除相邻用户相同策略（通过 excludeIdx 参数）。
    • 返回最小消耗值的索引。

  3. 主逻辑函数 getResult：

    • 遍历每个用户，调用 getMinEleIdx 函数选择局部最优策略。
    • 累加每个用户选择的策略消耗，得到总消耗。
    • 返回总消耗。

  4. 输出结果：

    • 调用 getResult 函数并输出结果。

C语言版本

代码实现

#include <stdio.h>
#include <limits.h> // 用于引入 INT_MAX// 辅助函数：找到当前用户可选策略中消耗最小的策略索引
int getMinEleIdx(int arr[], int arr_size, int excludeIdx) {int minEleVal = INT_MAX; // 初始化最小消耗值为最大整数int minEleIdx = -1;      // 初始化最小消耗值的索引为 -1// 遍历策略消耗数组for (int i = 0; i < arr_size; i++) {if (i == excludeIdx) continue; // 排除相邻用户相同策略// 如果当前策略消耗小于等于最小消耗值，则更新最小消耗值和索引if (arr[i] <= minEleVal) {minEleVal = arr[i];minEleIdx = i;}}return minEleIdx; // 返回最小消耗值的索引
}// 主逻辑函数：计算最优策略组合的总消耗
int getResult(int n, int res[][3]) {int last = -1; // 记录上一个用户选择的策略索引，初始值为 -1（表示没有限制）int sum = 0;   // 记录总消耗，初始值为 0// 遍历每个用户for (int i = 0; i < n; i++) {// 找到当前用户可选策略中消耗最小的策略索引last = getMinEleIdx(res[i], 3, last);// 将选择的策略消耗累加到总消耗中sum += res[i][last];}return sum; // 返回总消耗
}int main() {int n;scanf("%d", &n); // 读取用户总数 nint res[n][3]; // 定义二维数组存储每个用户的策略消耗值for (int i = 0; i < n; i++) {scanf("%d %d %d", &res[i][0], &res[i][1], &res[i][2]); // 读取每个用户的策略消耗值}// 调用主逻辑函数并输出结果printf("%d\n", getResult(n, res));return 0;
}

代码讲解

  1. 输入处理：

    • 使用 scanf 从控制台读取用户总数 n。
    • 定义二维数组 res，大小为 n x 3，用于存储每个用户的策略消耗值。
    • 使用 scanf 读取每个用户的策略消耗值。

  2. 辅助函数 getMinEleIdx：

    • 找到当前用户可选策略中消耗最小的策略索引。
    • 排除相邻用户相同策略（通过 excludeIdx 参数）。
    • 返回最小消耗值的索引。

  3. 主逻辑函数 getResult：

    • 遍历每个用户，调用 getMinEleIdx 函数选择局部最优策略。
    • 累加每个用户选择的策略消耗，得到总消耗。
    • 返回总消耗。

  4. 输出结果：

    • 调用 getResult 函数并输出结果。

示例运行

输入
3
15 8 17
12 20 9
11 7 5
执行过程：
  1. 读取 n = 3。
  2. 读取策略消耗值：
    [[15, 8, 17],[12, 20, 9],[11, 7, 5]
]
  3. 调用 getResult(n, res)：
    • 第 1 个用户：
      • 可选策略：A、B、C。
      • 消耗值：15、8、17。
      • 选择消耗最小的策略 B，索引为 1，消耗为 8。
    • 第 2 个用户：
      • 不能选择 B 策略（与第 1 个用户相同）。
      • 可选策略：A、C。
      • 消耗值：12、9。
      • 选择消耗最小的策略 C，索引为 2，消耗为 9。
    • 第 3 个用户：
      • 不能选择 C 策略（与第 2 个用户相同）。
      • 可选策略：A、B。
      • 消耗值：11、7。
      • 选择消耗最小的策略 B，索引为 1，消耗为 7。
    • 总消耗：8 + 9 + 7 = 24。
  4. 输出 24。

总结

  • C++ 版本：使用了 cin 和 cout 进行输入输出，代码简洁易读。
  • C语言版本：使用了 scanf 和 printf 进行输入输出，代码稍显复杂，但更贴近底层。

两种版本的代码逻辑一致，均通过局部最优选择规则，高效地计算了用户调度策略的最优总消耗。

六、尾言

什么是华为OD？

华为OD（Outsourcing Developer，外包开发工程师）是华为针对软件开发工程师岗位的一种招聘形式，主要包括笔试、技术面试以及综合面试等环节。尤其在笔试部分，算法题的机试至关重要。

为什么刷题很重要？

  1. 机试是进入技术面的第一关：
    华为OD机试（常被称为机考）主要考察算法和编程能力。只有通过机试，才能进入后续的技术面试环节。

  2. 技术面试需要手撕代码：
    技术一面和二面通常会涉及现场编写代码或算法题。面试官会注重考察候选人的思路清晰度、代码规范性以及解决问题的能力。因此提前刷题、多练习是通过面试的重要保障。

  3. 入职后的可信考试：
    入职华为后，还需要通过“可信考试”。可信考试分为三个等级：

    • 入门级：主要考察基础算法与编程能力。
    • 工作级：更贴近实际业务需求，可能涉及复杂的算法或与工作内容相关的场景题目。
    • 专业级：最高等级，考察深层次的算法以及优化能力，与薪资直接挂钩。

刷题策略与说明：

2024年8月14日之后，华为OD机试的题库转为 E卷，由往年题库（D卷、A卷、B卷、C卷）和全新题目组成。刷题时可以参考以下策略：

  1. 关注历年真题：

    • 题库中的旧题占比较大，建议优先刷历年的A卷、B卷、C卷、D卷题目。
    • 对于每道题目，建议深度理解其解题思路、代码实现，以及相关算法的适用场景。

  2. 适应新题目：

    • E卷中包含全新题目，需要掌握全面的算法知识和一定的灵活应对能力。
    • 建议关注新的刷题平台或交流群，获取最新题目的解析和动态。

  3. 掌握常见算法：
    华为OD考试通常涉及以下算法和数据结构：

    • 排序算法（快速排序、归并排序等）
    • 动态规划（背包问题、最长公共子序列等）
    • 贪心算法
    • 栈、队列、链表的操作
    • 图论（最短路径、最小生成树等）
    • 滑动窗口、双指针算法

  4. 保持编程规范：

    • 注重代码的可读性和注释的清晰度。
    • 熟练使用常见编程语言，如C++、Java、Python等。

如何获取资源？

  1. 官方参考：

    • 华为招聘官网或相关的招聘平台会有一些参考信息。
    • 华为OD的相关公众号可能也会发布相关的刷题资料或学习资源。

  2. 加入刷题社区：

    • 找到可信的刷题交流群，与其他备考的小伙伴交流经验。
    • 关注知名的刷题网站，如LeetCode、牛客网等，这些平台上有许多华为OD的历年真题和解析。

  3. 寻找系统性的教程：

    • 学习一本经典的算法书籍，例如《算法导论》《剑指Offer》《编程之美》等。
    • 完成系统的学习课程，例如数据结构与算法的在线课程。

积极心态与持续努力：

刷题的过程可能会比较枯燥，但它能够显著提升编程能力和算法思维。无论是为了通过华为OD的招聘考试，还是为了未来的职业发展，这些积累都会成为重要的财富。

考试注意细节

  1. 本地编写代码

    • 在本地 IDE（如 VS Code、PyCharm 等）上编写、保存和调试代码，确保逻辑正确后再复制粘贴到考试页面。这样可以减少语法错误，提高代码准确性。

  2. 调整心态，保持冷静

    • 遇到提示不足或实现不确定的问题时，不必慌张，可以采用更简单或更有把握的方法替代，确保思路清晰。

  3. 输入输出完整性

    • 注意训练和考试时都需要编写完整的输入输出代码，尤其是和题目示例保持一致。完成代码后务必及时调试，确保功能符合要求。

  4. 快捷键使用

    • 删除行可用 Ctrl+D，复制、粘贴和撤销分别为 Ctrl+C，Ctrl+V，Ctrl+Z，这些可以正常使用。
    • 避免使用 Ctrl+S，以免触发浏览器的保存功能。

  5. 浏览器要求

    • 使用最新版的 Google Chrome 浏览器完成考试，确保摄像头开启并正常工作。考试期间不要切换到其他网站，以免影响考试成绩。

  6. 交卷相关

    • 答题前，务必仔细查看题目示例，避免遗漏要求。
    • 每完成一道题后，点击【保存并调试】按钮，多次保存和调试是允许的，系统会记录得分最高的一次结果。完成所有题目后，点击【提交本题型】按钮。
    • 确保在考试结束前提交试卷，避免因未保存或调试失误而丢分。

  7. 时间和分数安排

    • 总时间：150 分钟；总分：400 分。
    • 试卷结构：2 道一星难度题（每题 100 分），1 道二星难度题（200 分）。及格分为 150 分。合理分配时间，优先完成自己擅长的题目。

  8. 考试环境准备

    • 考试前请备好草稿纸和笔。考试中尽量避免离开座位，确保监控画面正常。
    • 如需上厕所，请提前规划好时间以减少中途离开监控的可能性。

  9. 技术问题处理

    • 如果考试中遇到断电、断网、死机等技术问题，可以关闭浏览器并重新打开试卷链接继续作答。
    • 出现其他问题，请第一时间联系 HR 或监考人员进行反馈。

祝你考试顺利，取得理想成绩！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/6372.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

FPGA中场战事

FPGA中场战事

2023年10月3日，英特尔宣布由桑德拉里维拉(Sandra Rivera)担任“分拆”后独立运营的可编程事业部首席执行官。 从数据中心和人工智能(DCAI)部门总经理，转身为执掌该业务的CEO，对她取得像AMD掌门人苏姿丰博士类似的成功，无疑抱以厚望。 十年前，英特尔花费167亿美元真金白银…
阅读更多...
从手动到智能：自动化三维激光扫描

从手动到智能：自动化三维激光扫描

三维扫描&#xff0c;是通过先进三维扫描技术获取产品和物体的形面三维数据&#xff0c;建立实物的三维图档&#xff0c;满足各种实物3D模型数据获取、三维数字化展示、3D多媒体开发、三维数字化存档、逆向设计、产品开发、直接3D打印制造或辅助加工制造等一系列的应用。 传统的…
阅读更多...
电容的一些常用数值

电容的一些常用数值

如果是滤高频信号的小电容一般采用100nF 如果是滤低频信号的大电容一般采用10uF(10000nF) 比如这个LDO降压 两个一起用滤波效果会更好 如果想要供电引脚悬空&#xff0c;按理不能悬空&#xff0c;所以应该接大电阻接地&#xff0c;一般采用5.1KΩ 比如这个6Pin USB-TypeC的…
阅读更多...
编写子程序

编写子程序

实验内容、程序清单及运行结果 编写子程序&#xff08;课本实验10&#xff09; 1.显示字符串 问题显示字符串是现象工作中经常用到的功能&#xff0c;应该编写一个通用的子程序来实现这个功能。我们应该提供灵活的调用接口&#xff0c;使调用者可以决定显示的位置&#xff0…
阅读更多...
亚马逊新店铺流量怎么提升？自养号测评新趋势

亚马逊新店铺流量怎么提升？自养号测评新趋势

在竞争激烈的电商市场中&#xff0c;亚马逊新店铺如何在众多竞争者中脱颖而出&#xff0c;提升流量成为一大难题。对于新手卖家来说&#xff0c;掌握正确的流量提升策略至关重要。本文将为您揭秘亚马逊新店铺流量提升的方法&#xff0c;助您快速打开市场&#xff0c;实现业绩增…
阅读更多...
FPGA自分频产生的时钟如何使用？

FPGA自分频产生的时钟如何使用？

对于频率比较小的时钟&#xff0c;使用clocking wizard IP往往不能产生&#xff0c;此时就需要我们使用代码进行自分频&#xff0c;自分频产生的时钟首先应该经过BUFG处理&#xff0c;然后还需要进行时钟约束&#xff0c;处理之后才能使用。
阅读更多...
JQuery基本介绍和使用方法

JQuery基本介绍和使用方法

JQuery基本介绍和使用方法 W3C 标准给我们提供了⼀系列的函数, 让我们可以操作: ⽹⻚内容⽹⻚结构⽹⻚样式 但是原⽣的JavaScript提供的API操作DOM元素时, 代码⽐较繁琐, 冗⻓. 我们可以使⽤JQuery来操作⻚⾯对象. jQuery是⼀个快速、简洁且功能丰富的JavaScript框架, 于20…
阅读更多...
Go语言中的值类型和引用类型特点

Go语言中的值类型和引用类型特点

一、值类型 值类型的数据直接包含值&#xff0c;当它们被赋值给一个新的变量或者作为参数传递给函数时&#xff0c;实际上是创建了原值的一个副本。这意味着对新变量的修改不会影响原始变量的值。 Go中的值类型包括&#xff1a; 基础类型&#xff1a;int&#xff0c;float64…
阅读更多...
15-spring整合mybatis方式一

15-spring整合mybatis方式一

spring整合mybatis 方式一【重要】 步骤: 1.导入相关jar包 junit mybatis mysql数据库 spring相关的 aop织入 mybatis-spring 【new】 junit junit 4.12 mysql mysql-connector-java 8.0.23 org.mybatis mybatis 3.5.2 org.springframework spring-webmvc 5…
阅读更多...
豆包MarsCode：小C的类二进制拼图

豆包MarsCode：小C的类二进制拼图

问题描述 思路分析 1. 类二进制数字定义 从题目中我们可以知道&#xff0c;类二进制数字是仅由 0 和 1 组成的数字。比如&#xff1a;1, 10, 100, 101, 110 等等&#xff0c;这些数字都是合法的类二进制数字。换句话说&#xff0c;类二进制数字可以看作是 “二进制表示法” 对…
阅读更多...
中国综合算力指数（2024年）报告汇总PDF洞察（附原数据表）

中国综合算力指数（2024年）报告汇总PDF洞察（附原数据表）

原文链接&#xff1a; https://tecdat.cn/?p39061 在全球算力因数字化技术发展而竞争加剧&#xff0c;我国积极推进算力发展并将综合算力作为数字经济核心驱动力的背景下&#xff0c;该报告对我国综合算力进行研究。 中国算力大会发布的《中国综合算力指数&#xff08;2024年…
阅读更多...
Vue中设置报错页面和“Uncaught runtime errors”弹窗关闭

Vue中设置报错页面和“Uncaught runtime errors”弹窗关闭

文章目录 前言操作步骤大纲1.使用Vue自带的报错捕获机制添加报错信息2.在接口报错部分添加相同机制3.把报错信息添加到Vuex中方便全局使用4.添加报错页面备用5.app页面添加if判断替换报错界面 效果备注&#xff1a;vue项目中Uncaught runtime errors:怎样关闭 前言 在开发Vue项…
阅读更多...
单调栈详解

单调栈详解

文章目录 单调栈详解一、引言二、单调栈的基本原理1、单调栈的定义2、单调栈的维护 三、单调栈的应用场景四、使用示例1、求解下一个更大元素2、计算柱状图中的最大矩形面积 五、总结 单调栈详解 一、引言 单调栈是一种特殊的栈结构&#xff0c;它在栈的基础上增加了单调性约束…
阅读更多...
算法题之栈与队列：理论基础与常用操作接口

算法题之栈与队列：理论基础与常用操作接口

栈与队列 &#xff08;1&#xff09;理论基础 栈&#xff1a;先进后出的数据结构 队列&#xff1a;先进先出的数据结构 栈提供push 和 pop 等等接口&#xff0c;所有元素必须符合先进后出规则&#xff0c;所以栈不提供走访功能&#xff0c;也不提供迭代器(iterator)。 不像是…
阅读更多...
snippets router pinia axios mock

snippets router pinia axios mock

文章目录 补充VS Code 代码片段注册自定义组件vue routerpinia删除vite创建项目时默认的文件axiosmock3.0.x版本的 viteMockServe 补充 为文章做补充&#xff1a;https://blog.csdn.net/yavlgloss/article/details/140063387 VS Code 代码片段 为当前项目创建 Snippets {&quo…
阅读更多...
llama-2-7b权重文件转hf格式及模型使用

llama-2-7b权重文件转hf格式及模型使用

目录 1. obtain llama weights 2. convert llama weights files into hf format 3. use llama2 to generate text 1. obtain llama weights &#xff08;1&#xff09;登录huggingface官网&#xff0c;搜索llama-2-7b &#xff08;2&#xff09;填写申请表单&#xff0c;VP…
阅读更多...
图形化数据报文转换映射工具

图形化数据报文转换映射工具

目录 概要整体架构流程技术名词解释技术细节小结 概要 在当今数字化时代&#xff0c;数据的处理和分析是企业、科研机构以及各类组织日常运营的核心环节。数据来源广泛&#xff0c;格式多样&#xff0c;常见的数据格式包括XML&#xff08;可扩展标记语言&#xff09;和JSON&a…
阅读更多...
计算机视觉算法实战——无人机检测

计算机视觉算法实战——无人机检测

✨个人主页欢迎您的访问 ✨期待您的三连 ✨ ✨个人主页欢迎您的访问 ✨期待您的三连 ✨ ✨个人主页欢迎您的访问 ✨期待您的三连✨ ​ ​ 1. 引言✨✨ 随着无人机技术的快速发展&#xff0c;无人机在农业、物流、监控等领域的应用越来越广泛。然而&#xff0c;无人机的滥用也带…
阅读更多...
我谈概率论与数理统计的知识体系

我谈概率论与数理统计的知识体系

学习概率统计二十多年后&#xff0c;在廖老师的指导下&#xff0c;厘清了各章之间的关系。本来就是一条线两个分支&#xff0c;脉络很清晰。 分支一&#xff1a;从随机现象到样本空间到随机事件再到概率。 从随机事件到随机变量&#xff1a;为了进行定量的数学处理&#xff0…
阅读更多...
docker ubuntu:20.04构建c++ grpc环境

docker ubuntu:20.04构建c++ grpc环境

由c grpc必须源码编译&#xff0c;ubuntu版本不同可能出现的问题也不同&#xff0c;这里分享下我的构建过程。 我是vscode结合docker去安装c虚拟环境&#xff0c;我不想污染本机环境。 vscode的插件Dev Containers Dockerfile如下(如果单纯是ubuntu环境构建&#xff0c;可忽略该…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023