【2024年华为OD机试】 (C卷,100分)- 最大括号深度（Java JS PythonC/C++）

一、问题描述

题目描述

现有一字符串仅由 ‘(‘，’)’，’{‘，’}’，’[‘，’]’六种括号组成。

若字符串满足以下条件之一，则为无效字符串：

①任一类型的左右括号数量不相等；

②存在未按正确顺序（先左后右）闭合的括号。

输出括号的最大嵌套深度，若字符串无效则输出0。

0≤字符串长度≤100000

输入描述

一个只包括 ‘(‘，’)’，’{‘，’}’，’[‘，’]’的字符串

输出描述

一个整数，最大的括号深度

用例

用例1

输入

[]

输出

1

说明
有效字符串，最大嵌套深度为1

用例2

输入

([]{()})

输出

3

说明
有效字符串，最大嵌套深度为3

用例3

输入

(]

输出

0

说明
无效字符串，有两种类型的左右括号数量不相等

用例4

输入

([)]

输出

0

说明
无效字符串，存在未按正确顺序闭合的括号

用例5

输入

)(

输出

0

说明
无效字符串，存在未按正确顺序闭合的括号。

题目解析

考察点

考察栈结构的应用。

解析思路

1. 问题理解：
   • 本题要求判断括号字符串的有效性，并计算最大嵌套深度。
2. 栈结构：
   • 使用栈结构来判断括号的对称性。
   • 遍历字符串，对于每个字符：
     • 如果是左括号（’(’，’[’，’{’），则入栈。
     • 如果是右括号（’)’，’]’，’}’），则检查栈顶元素是否为对应的左括号：
       • 如果是，出栈并更新当前深度。
       • 如果不是，字符串无效，返回0。
3. 最大深度计算：
   • 使用一个变量 maxDepth 记录最大嵌套深度。
   • 每次入栈时，当前深度加1。
   • 每次出栈时，更新 maxDepth。
   • 如果遇到右括号但栈为空，说明字符串无效，返回0。
4. 最终检查：
   • 遍历结束后，检查栈是否为空：
     • 如果不为空，说明有未闭合的左括号，字符串无效，返回0。
     • 如果为空，返回 maxDepth。

详细步骤

1. 初始化变量：
   • 初始化一个空栈 stack。
   • 初始化 maxDepth 为0，用于记录最大嵌套深度。
   • 初始化 currentDepth 为0，用于记录当前嵌套深度。
2. 遍历字符串：
   • 对于每个字符 ch：
     • 如果 ch 是左括号，入栈并 currentDepth++。
     • 如果 ch 是右括号：
       • 如果栈为空，返回0。
       • 否则，检查栈顶元素是否为对应的左括号：
         • 如果是，出栈并 currentDepth--。
         • 如果不是，返回0。
       • 更新 maxDepth。
3. 最终检查：
   • 如果栈不为空，返回0。
   • 否则，返回 maxDepth。

注意事项

• 栈的使用：确保正确使用栈来判断括号的对称性。
• 最大深度：正确更新当前深度和最大深度。
• 有效性检查：确保字符串满足所有有效性条件。

二、JavaScript算法源码

代码功能简介

这段代码的目的是计算给定字符串中嵌套括号的最大深度，同时判断括号是否是合法的匹配。合法的意思是，括号必须成对出现，且嵌套结构正确。

代码详细注释

// 导入 Node.js 内置模块 readline，用于处理控制台输入输出
const readline = require("readline");

// 创建 readline 接口实例，用于从控制台中读取输入
const rl = readline.createInterface({
  input: process.stdin, // 指定标准输入流
  output: process.stdout, // 指定标准输出流
});

// 监听控制台中输入的每一行数据
rl.on("line", (line) => {
  // 调用 getMaxDepth 函数计算输入字符串的最大括号嵌套深度
  console.log(getMaxDepth(line));
});

// 定义一个函数 getMaxDepth，用于计算括号的最大嵌套深度
function getMaxDepth(str) {
  // 定义一个映射关系，用于匹配左括号和右括号
  const map = {
    ")": "(", // 右圆括号对应左圆括号
    "]": "[", // 右方括号对应左方括号
    "}": "{", // 右花括号对应左花括号
  };

  // 定义一个栈，用于存储左括号
  const stack = [];

  // 初始化最大嵌套深度为 0
  let maxDepth = 0;

  // 遍历字符串的每一个字符
  for (let i = 0; i < str.length; i++) {
    let c = str[i]; // 当前字符

    // 检查栈顶元素是否与当前字符匹配（当前字符是右括号，且与栈顶左括号匹配）
    if (stack.length > 0 && map[c] === stack.at(-1)) {
      stack.pop(); // 弹出栈顶左括号
    } else {
      stack.push(c); // 当前字符入栈（通常是左括号）
      // 更新最大嵌套深度
      maxDepth = Math.max(maxDepth, stack.length);
    }
  }

  // 如果栈中仍然有剩余的字符，说明括号不匹配，返回 0 表示无效
  if (stack.length) return 0;

  // 返回最大括号嵌套深度
  return maxDepth;
}

代码逻辑讲解

1. 输入处理

使用 readline 模块监听控制台输入：

• 用户在控制台中输入字符串后，rl.on("line", callback) 会捕获输入，并将其传递给回调函数处理。
• 在回调函数中，调用 getMaxDepth 方法计算输入字符串最大括号嵌套深度，并输出结果。

2. 括号嵌套深度的计算逻辑

getMaxDepth 函数的核心逻辑是通过栈的数据结构判断括号是否匹配，并计算最大括号嵌套深度。

• 栈的作用:

  • 用于存储尚未匹配的左括号。
  • 每遇到一个右括号时，检查是否能与栈顶左括号匹配。如果匹配，则弹出栈顶元素；否则，将右括号入栈（视为无效括号）。

• 最大深度的更新:

  • 每当有括号入栈时，更新当前栈的最大长度为 maxDepth，这表示当前括号嵌套的深度。

• 合法性判断:

  • 如果字符串遍历完成后，栈中仍然有未匹配的左括号（栈非空），说明括号不合法，直接返回 0。

示例解析

示例1

输入：

(()[{}])

执行过程：

1. 遇到 ( 入栈，stack = ['(']，maxDepth = 1
2. 遇到 ( 入栈，stack = ['(', '(']，maxDepth = 2
3. 遇到 ) 出栈，stack = ['(']，maxDepth = 2
4. 遇到 [ 入栈，stack = ['(', '[']，maxDepth = 2
5. 遇到 { 入栈，stack = ['(', '[', '{']，maxDepth = 3
6. 遇到 } 出栈，stack = ['(', '[']，maxDepth = 3
7. 遇到 ] 出栈，stack = ['(']，maxDepth = 3
8. 遇到 ) 出栈，stack = []，maxDepth = 3

输出：

3

示例2

输入：

([)]

执行过程：

1. 遇到 ( 入栈，stack = ['(']，maxDepth = 1
2. 遇到 [ 入栈，stack = ['(', '[']，maxDepth = 2
3. 遇到 ) 无法匹配栈顶 [，入栈，stack = ['(', '[', ')']
4. 遇到 ] 无法匹配栈顶 )，入栈，stack = ['(', '[', ')', ']']

栈非空，返回 0。

输出：

0

代码总结

• 时间复杂度:

  • 遍历字符串一次，时间复杂度为 (O(n))。
  • 栈的操作（入栈、出栈）时间复杂度为 (O(1))。
  • 因此总体时间复杂度为 (O(n))。

• 空间复杂度:

  • 栈的空间复杂度为 (O(n))，取决于字符串中未匹配的括号数量。

应用场景

1. 括号匹配校验:
   用于验证括号是否成对出现，常用于编译器和解释器的语法分析。

2. 计算嵌套深度:
   可用于分析复杂表达式的结构，例如数学表达式或代码中的嵌套层数。

如果有其他疑问，我很乐意为您解答！😊

三、Java算法源码

功能简介

这段代码的功能是计算一个输入字符串中括号的最大嵌套深度，同时检查括号是否是匹配且合法的。合法的意思是括号必须成对出现，并且嵌套结构正确。

详细中文注释和讲解

import java.util.HashMap; // 用于存储左右括号的映射关系
import java.util.LinkedList; // 用作栈结构
import java.util.Scanner; // 用于读取控制台输入

public class Main {
  // 主程序入口
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in); // 创建 Scanner 对象，用于接收用户输入
    String s = sc.nextLine(); // 读取用户输入的一行字符串
    System.out.println(getResult(s)); // 调用 getResult 函数计算结果，并打印输出
  }

  // 算法入口：计算括号的最大嵌套深度
  public static int getResult(String s) {
    // 使用 HashMap 存储右括号与左括号之间的映射关系
    HashMap<Character, Character> map = new HashMap<>();
    map.put(')', '('); // 右圆括号对应左圆括号
    map.put(']', '['); // 右方括号对应左方括号
    map.put('}', '{'); // 右花括号对应左花括号

    // 使用 LinkedList 作为栈，用于存储左括号
    LinkedList<Character> stack = new LinkedList<>();

    // 初始化最大嵌套深度为 0
    int maxDepth = 0;

    // 遍历字符串的每一个字符
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i); // 获取当前字符

      // 如果当前字符是右括号，且栈非空，并且栈顶元素与当前右括号匹配
      if (stack.size() > 0 && map.get(c) == stack.getLast()) {
        stack.removeLast(); // 将栈顶元素弹出
      } else {
        // 否则，将当前字符入栈（通常是左括号或非法字符）
        stack.add(c);
        // 更新最大嵌套深度
        maxDepth = Math.max(maxDepth, stack.size());
      }
    }

    // 如果遍历结束后，栈非空，说明括号不匹配，返回 0
    if (stack.size() > 0) return 0;

    // 返回最大嵌套深度
    return maxDepth;
  }
}

代码逻辑讲解

1. 输入处理

主程序的 main 方法接收用户输入：

• 使用 Scanner 读取用户输入的一行字符串。
• 调用 getResult 函数对输入字符串进行处理，并输出结果。

2. 括号嵌套深度的计算逻辑

getResult 函数实现了括号嵌套深度的计算和匹配校验逻辑：

• HashMap 的作用：

  • 存储右括号与左括号的映射关系。
  • 当遍历到右括号时，可通过 map.get(c) 查询其对应的左括号。

• 栈的作用：

  • 栈用于存储尚未匹配的左括号。
  • 每遇到一个右括号时，检查栈顶元素是否与之匹配。如果匹配，则弹出栈顶元素；否则，将当前字符（可能是非法字符）加入栈中。

• 最大嵌套深度的更新：

  • 每当有括号入栈时，更新当前栈的最大长度为 maxDepth，这表示当前括号嵌套的深度。

• 非法括号检查：

  • 如果字符串遍历完成后，栈中仍然有未匹配的括号（栈非空），说明输入字符串不合法，直接返回 0。

示例解析

示例1

输入：

(()[{}])

执行过程：

1. 遇到 ( 入栈，stack = ['(']，maxDepth = 1
2. 遇到 ( 入栈，stack = ['(', '(']，maxDepth = 2
3. 遇到 ) 出栈，stack = ['(']，maxDepth = 2
4. 遇到 [ 入栈，stack = ['(', '[']，maxDepth = 2
5. 遇到 { 入栈，stack = ['(', '[', '{']，maxDepth = 3
6. 遇到 } 出栈，stack = ['(', '[']，maxDepth = 3
7. 遇到 ] 出栈，stack = ['(']，maxDepth = 3
8. 遇到 ) 出栈，stack = []，maxDepth = 3

输出：

3

示例2

输入：

([)]

执行过程：

1. 遇到 ( 入栈，stack = ['(']，maxDepth = 1
2. 遇到 [ 入栈，stack = ['(', '[']，maxDepth = 2
3. 遇到 ) 无法匹配栈顶的 [，将 ) 入栈，stack = ['(', '[', ')']
4. 遇到 ] 无法匹配栈顶的 )，将 ] 入栈，stack = ['(', '[', ')', ']']

结果：
栈非空，括号不匹配，返回 0。

输出：

0

代码总结

• 时间复杂度:

  • 遍历字符串一次，时间复杂度为 (O(n))。
  • 栈的操作（入栈、出栈）时间复杂度为 (O(1))。
  • 因此总体时间复杂度为 (O(n))。

• 空间复杂度:

  • 栈的空间复杂度为 (O(n))，取决于字符串中未匹配的括号数量。

• 特点:

  • 使用了栈结构，用于括号匹配。
  • 最大嵌套深度通过栈的最大长度动态计算。
  • 提供了非法括号的检测，返回 0 表示括号不合法。

应用场景

1. 编程语言的语法分析：
   用于验证代码中括号是否匹配，例如 if、while 等语句括号的合法性。

2. 数学表达式检查：
   验证嵌套的数学表达式是否正确，例如 ((2 + 3) * [5 / {1 + 1}])。

如果您有其他问题，欢迎随时提问！😊

四、Python算法源码

功能简介

这段代码的目标是判断一个包含括号的字符串是否合法（括号配对正确且嵌套合理），并计算字符串中括号的最大嵌套深度。
最大嵌套深度是指括号嵌套时的最大深度，如 "(([]))" 的嵌套深度为 3。

详细代码注释和讲解

# 输入获取
s = input()

• 使用 input() 方法从标准输入中读取用户输入的字符串。
• 用户输入的字符串会存储到变量 s 中。
• 输入字符串可能包含括号 ()[]{}，也可能包含其他不相关的字符。

# 算法入口
def getResult():
    # 定义一个字典，存储右括号与左括号的对应关系
    map = {
        ")": "(",  # 右圆括号对应左圆括号
        "]": "[",  # 右方括号对应左方括号
        "}": "{"   # 右花括号对应左花括号
    }

    # 使用一个列表作为栈，用于存储未匹配的左括号
    stack = []

    # 初始化最大嵌套深度为 0
    maxDepth = 0

    # 遍历输入字符串的每一个字符
    for i in range(len(s)):
        c = s[i]  # 当前字符

        # 如果栈非空，并且当前字符是右括号，且与栈顶左括号匹配
        if len(stack) > 0 and map.get(c) is not None and map[c] == stack[-1]:
            stack.pop()  # 弹出匹配的左括号
        else:
            # 如果当前字符是左括号或其他字符，将其加入栈
            stack.append(c)

            # 更新最大嵌套深度
            # 栈的长度表示当前嵌套深度
            maxDepth = max(maxDepth, len(stack))

    # 遍历结束后，如果栈不为空，说明有未匹配的括号，返回 0 表示不合法
    if len(stack) > 0:
        return 0

    # 如果栈为空，返回最大嵌套深度
    return maxDepth

核心逻辑讲解

1. map 字典的作用

• map 用于存储右括号对应的左括号。
• 在遍历字符串时，如果遇到右括号（如 )、] 或 }），可以通过 map[c] 查找其对应的左括号，用于匹配栈顶括号。

2. 栈的作用

• 栈的主要用来存储尚未匹配的左括号。
• 遇到右括号时，检查栈顶的元素是否与当前右括号匹配。如果匹配，则弹出栈顶元素；否则将当前字符加入栈。
• 栈长度的最大值表示括号嵌套的最大深度。

3. 嵌套深度的计算

• 每次将括号加入栈时，更新当前的嵌套深度：

  maxDepth = max(maxDepth, len(stack))
  

• 栈的长度表示当前的嵌套深度，因此每次栈增加新元素时都需要更新最大深度。

4. 合法性检查

• 遍历字符串后，如果栈中仍有剩余元素，说明存在非法括号（比如多余的左括号未匹配），直接返回 0。
• 如果栈为空，则表示括号配对完全正确，返回最大嵌套深度。

示例解析

示例 1

输入：

(()[{}])

执行过程：

1. 遇到 (，入栈，stack = ['(']，maxDepth = 1
2. 遇到 (，入栈，stack = ['(', '(']，maxDepth = 2
3. 遇到 )，出栈，stack = ['(']，maxDepth = 2
4. 遇到 [，入栈，stack = ['(', '[']，maxDepth = 2
5. 遇到 {，入栈，stack = ['(', '[', '{']，maxDepth = 3
6. 遇到 }，出栈，stack = ['(', '[']，maxDepth = 3
7. 遇到 ]，出栈，stack = ['(']，maxDepth = 3
8. 遇到 )，出栈，stack = []，maxDepth = 3

输出：

3

示例 2

输入：

([)]

执行过程：

1. 遇到 (，入栈，stack = ['(']，maxDepth = 1
2. 遇到 [，入栈，stack = ['(', '[']，maxDepth = 2
3. 遇到 )，无法匹配栈顶的 [，将 ) 入栈，stack = ['(', '[', ')']
4. 遇到 ]，无法匹配栈顶的 )，将 ] 入栈，stack = ['(', '[', ')', ']']

结果：
栈非空，说明括号不合法。

输出：

0

示例 3

输入：

[({})]

执行过程：

1. 遇到 [，入栈，stack = ['[']，maxDepth = 1
2. 遇到 (，入栈，stack = ['[', '(']，maxDepth = 2
3. 遇到 {，入栈，stack = ['[', '(', '{']，maxDepth = 3
4. 遇到 }，出栈，stack = ['[', '(']，maxDepth = 3
5. 遇到 )，出栈，stack = ['[']，maxDepth = 3
6. 遇到 ]，出栈，stack = []，maxDepth = 3

输出：

3

代码总结

时间复杂度：

• 遍历字符串的时间复杂度为 (O(n))，其中 (n) 是字符串的长度。
• 栈的 append 和 pop 操作的时间复杂度为 (O(1))。
• 因此总体时间复杂度为 (O(n))。

空间复杂度：

• 栈的空间复杂度为 (O(n))，取决于字符串中未匹配的左括号数量。

核心特点：

• 使用字典 map 和栈实现了括号匹配和嵌套深度的计算。
• 同时支持三种括号：()、[] 和 {}。

应用场景

1. 编程语言的语法解析：
   用于验证代码中括号是否匹配，例如 if、for 等语句的括号合法性。

2. 数学表达式检查：
   验证复杂数学表达式（如 (2 + [3 * {5 - 1}])）中的括号嵌套是否正确。

3. 数据结构练习：
   使用栈解决括号匹配问题是数据结构学习中的常见案例。

如果您有其他问题，欢迎随时提问！😊

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

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

C++ 代码

#include <iostream>
#include <stack>
#include <unordered_map>
using namespace std;

// 算法入口
int getResult(const string &s) {
    // 定义括号匹配规则
    unordered_map<char, char> map = {
        {')', '('},
        {']', '['},
        {'}', '{'}
    };

    // 使用栈来检查括号匹配
    stack<char> stack;

    // 记录最大栈深度（即最大嵌套深度）
    int maxDepth = 0;

    // 遍历字符串中的每个字符
    for (char c : s) {
        // 如果当前字符是右括号，并且栈顶元素是对应的左括号
        if (!stack.empty() && map.count(c) && map[c] == stack.top()) {
            stack.pop(); // 弹出栈顶元素（匹配成功）
        } else {
            stack.push(c); // 将当前字符压入栈中
            maxDepth = max(maxDepth, (int)stack.size()); // 更新最大深度
        }
    }

    // 如果栈不为空，说明有未匹配的括号，返回 0
    if (!stack.empty()) {
        return 0;
    }

    // 返回最大嵌套深度
    return maxDepth;
}

int main() {
    // 输入获取
    string s;
    cin >> s;

    // 算法调用
    cout << getResult(s) << endl;

    return 0;
}

C语言代码

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

// 定义栈的最大容量
#define MAX_SIZE 1000

// 定义栈结构
typedef struct {
    char data[MAX_SIZE];
    int top;
} Stack;

// 初始化栈
void initStack(Stack *stack) {
    stack->top = -1; // 栈顶指针初始化为 -1，表示栈为空
}

// 判断栈是否为空
int isEmpty(Stack *stack) {
    return stack->top == -1;
}

// 判断栈是否已满
int isFull(Stack *stack) {
    return stack->top == MAX_SIZE - 1;
}

// 入栈
void push(Stack *stack, char c) {
    if (isFull(stack)) {
        printf("Stack overflow!\n");
        exit(1);
    }
    stack->data[++stack->top] = c;
}

// 出栈
char pop(Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack underflow!\n");
        exit(1);
    }
    return stack->data[stack->top--];
}

// 获取栈顶元素
char peek(Stack *stack) {
    if (isEmpty(stack)) {
        printf("Stack is empty!\n");
        exit(1);
    }
    return stack->data[stack->top];
}

// 算法入口
int getResult(const char *s) {
    // 定义括号匹配规则
    char map[128] = {0};
    map[')'] = '(';
    map[']'] = '[';
    map['}'] = '{';

    // 初始化栈
    Stack stack;
    initStack(&stack);

    // 记录最大栈深度（即最大嵌套深度）
    int maxDepth = 0;

    // 遍历字符串中的每个字符
    for (int i = 0; s[i] != '\0'; i++) {
        char c = s[i];

        // 如果当前字符是右括号，并且栈顶元素是对应的左括号
        if (!isEmpty(&stack) && map[c] != 0 && map[c] == peek(&stack)) {
            pop(&stack); // 弹出栈顶元素（匹配成功）
        } else {
            push(&stack, c); // 将当前字符压入栈中
            maxDepth = maxDepth > stack.top + 1 ? maxDepth : stack.top + 1; // 更新最大深度
        }
    }

    // 如果栈不为空，说明有未匹配的括号，返回 0
    if (!isEmpty(&stack)) {
        return 0;
    }

    // 返回最大嵌套深度
    return maxDepth;
}

int main() {
    // 输入获取
    char s[MAX_SIZE];
    scanf("%s", s);

    // 算法调用
    printf("%d\n", getResult(s));

    return 0;
}

代码讲解

C++ 代码讲解

1. 数据结构：

   • 使用 unordered_map 存储括号匹配规则，键为右括号，值为对应的左括号。
   • 使用 stack 来检查括号的匹配情况。

2. 算法逻辑：

   • 遍历字符串中的每个字符：
     • 如果是右括号，并且栈顶元素是对应的左括号，则弹出栈顶元素（匹配成功）。
     • 否则，将当前字符压入栈中，并更新最大深度。
   • 如果遍历结束后栈不为空，说明有未匹配的括号，返回 0。
   • 否则，返回最大嵌套深度。

3. 优点：

   • 使用 STL 容器（stack 和 unordered_map），代码简洁易读。
   • 自动管理内存，无需手动分配和释放。

C语言代码讲解

1. 数据结构：

   • 使用数组模拟栈，定义栈的最大容量 MAX_SIZE。
   • 使用 map 数组存储括号匹配规则，索引为右括号的 ASCII 值，值为对应的左括号。

2. 算法逻辑：

   • 遍历字符串中的每个字符：
     • 如果是右括号，并且栈顶元素是对应的左括号，则弹出栈顶元素（匹配成功）。
     • 否则，将当前字符压入栈中，并更新最大深度。
   • 如果遍历结束后栈不为空，说明有未匹配的括号，返回 0。
   • 否则，返回最大嵌套深度。

3. 优点：

   • 纯 C 语言实现，适合嵌入式或对性能要求较高的场景。
   • 手动管理栈，灵活性更高。

总结

• C++ 代码：使用 STL 容器，代码简洁，适合快速开发和维护。
• C语言代码：手动实现栈，适合对性能要求较高的场景或嵌入式开发。

两者功能相同，选择哪种语言取决于具体需求和开发环境。

六、尾言

什么是华为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 或监考人员进行反馈。

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