【2024年华为OD机试】 (C卷,200分)- 发广播（JavaScriptJava PythonC/C++）

一、问题描述

题目描述

某地有N个广播站，站点之间有些有连接，有些没有。有连接的站点在接受到广播后会互相发送。

给定一个N*N的二维数组matrix，数组的元素都是字符'0'或者'1'。

• matrix[i][j] = '1'，代表i和j站点之间有连接。
• matrix[i][j] = '0'，代表没连接。

现在要发一条广播，问初始最少给几个广播站发送，才能保证所有的广播站都收到消息。

输入描述

从stdin输入，共一行数据，表示二维数组的各行，用逗号分隔行。保证每行字符串所含的字符数一样的。

比如：110,110,001。

输出描述

返回初始最少需要发送广播站个数。

用例

用例1

• 输入：110,110,001
• 输出：2
• 说明：站点1和站点2直接有连接，站点3和其他的都没连接，所以开始至少需要给两个站点发送广播。

用例2

• 输入：100,010,001
• 输出：3
• 说明：3台服务器互不连接，所以需要分别广播这3台服务器。

用例3

• 输入：11,11
• 输出：1
• 说明：2台服务器相互连接，所以只需要广播其中一台服务器。

题目解析

题目中提到：“有连接的站点在接受到广播后会互相发送。” 这表明如果matrix[i][j] = '1'，则必然matrix[j][i] = '1'，即二维矩阵中元素值会沿左上右下对角线轴对称。

因此，解决本题，我们只需要看对角线的一侧即可。

并查集结构

为了构建连通图，我们可以使用并查集（Union-Find）结构。并查集本身是一个数组，数组的索引指代站点，数组的元素值指代当前索引站点的祖先站点。

例如，有5个站点，我们可以创建一个长度为5的数组arr，初始时，每个站点都可以视为互不相连的，即每个站点的祖先站点都是自己。

更新并查集

我们开始遍历输入的二维数组对角线一侧的站点连接情况，来更新并查集结构。

1. 如果matrix[i][j] = '1'，则将站点j的父站点更新为站点i。
2. 如果站点j已经有父站点，我们需要找到站点j的祖先站点，然后将祖先站点的父站点更新为站点i。

通过这种方式，我们可以构建出连通图，最终统计连通分量的数量即为初始最少需要发送广播站的个数。

示例

以输入11010,11000,00110,10110,00001为例：

• 站点0、1、2、3是互联的。
• 站点4没有任何连接。

因此，我们需要给至少两个站点发送广播。

总结

通过并查集结构，我们可以有效地构建连通图，并统计连通分量的数量，从而得出初始最少需要发送广播站的个数。

二、JavaScript算法源码

以下是代码的详细注释和讲解，帮助理解并查集（Union-Find）的实现以及如何解决广播站问题。

代码结构

1. 控制台输入获取：使用 readline 模块读取输入。
2. 主逻辑函数 getMinCount：计算最少需要发送广播的站点数量。
3. 并查集类 UnionFindSet：实现并查集的核心功能，包括查找和合并操作。

代码讲解

1. 控制台输入获取

const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.on("line", (line) => {
  const matrix = line.split(",").map((str) => str.split(""));
  console.log(getMinCount(matrix));
});

• 功能：从控制台读取输入，并将其转换为二维数组 matrix。
• 输入格式：输入是一行字符串，用逗号分隔，例如 "110,110,001"。
• 处理逻辑：
  • 使用 split(",") 将输入按逗号分隔成多行。
  • 使用 map 将每行字符串拆分为字符数组，例如 "110" 转换为 ['1', '1', '0']。
  • 调用 getMinCount 函数计算结果并输出。

2. 主逻辑函数 getMinCount

function getMinCount(matrix) {
  const n = matrix.length;

  // 初始化并查集
  const ufs = new UnionFindSet(n);

  // 遍历矩阵的上三角部分（因为矩阵是对称的）
  for (let i = 0; i < n; i++) {
    for (let j = i + 1; j < n; j++) {
      if (matrix[i][j] === "1") {
        // 如果站点 i 和 j 有连接，则合并它们
        ufs.union(i, j);
      }
    }
  }

  // 返回并查集中的连通分量数量
  return ufs.count;
}

• 功能：计算最少需要发送广播的站点数量。
• 逻辑：
  • 初始化并查集 ufs，大小为 n（站点数量）。
  • 遍历矩阵的上三角部分（因为矩阵是对称的，只需要遍历一半）。
  • 如果 matrix[i][j] === '1'，表示站点 i 和 j 有连接，调用 ufs.union(i, j) 合并它们。
  • 最终返回并查集中的连通分量数量 ufs.count，即最少需要发送广播的站点数量。

3. 并查集类 UnionFindSet

class UnionFindSet {
  constructor(n) {
    // 初始化父节点数组，每个站点的父节点初始为自己
    this.fa = new Array(n).fill(true).map((_, idx) => idx);
    // 初始化连通分量数量，初始时每个站点都是独立的
    this.count = n;
  }

  // 查找 x 的祖先节点（路径压缩优化）
  find(x) {
    if (x !== this.fa[x]) {
      // 递归查找祖先节点，并将路径上的所有节点直接指向祖先节点
      this.fa[x] = this.find(this.fa[x]);
      return this.fa[x];
    }
    return x;
  }

  // 合并 x 和 y 所在的集合
  union(x, y) {
    // 找到 x 和 y 的祖先节点
    let x_fa = this.find(x);
    let y_fa = this.find(y);

    // 如果祖先节点不同，则合并它们
    if (x_fa !== y_fa) {
      this.fa[y_fa] = x_fa; // 将 y 的祖先节点指向 x 的祖先节点
      this.count--; // 连通分量数量减 1
    }
  }
}

• 功能：实现并查集的核心功能，包括查找和合并操作。
• 属性：
  • fa：父节点数组，fa[x] 表示站点 x 的父节点。
  • count：连通分量数量，初始时每个站点都是独立的。
• 方法：
  • find(x)：
    • 查找站点 x 的祖先节点。
    • 使用路径压缩优化，将路径上的所有节点直接指向祖先节点，减少后续查找的时间复杂度。
  • union(x, y)：
    • 合并站点 x 和 y 所在的集合。
    • 如果它们的祖先节点不同，则将其中一个祖先节点指向另一个祖先节点，并减少连通分量数量。

代码运行示例

输入 1

110,110,001

• 矩阵：

  [['1', '1', '0'],
   ['1', '1', '0'],
   ['0', '0', '1']]
  

• 逻辑：
  • 站点 0 和 1 有连接，合并它们。
  • 站点 2 没有连接，独立成一个连通分量。
• 输出：2

输入 2

100,010,001

• 矩阵：

  [['1', '0', '0'],
   ['0', '1', '0'],
   ['0', '0', '1']]
  

• 逻辑：
  • 所有站点都没有连接，各自独立。
• 输出：3

输入 3

11,11

• 矩阵：

  [['1', '1'],
   ['1', '1']]
  

• 逻辑：
  • 站点 0 和 1 有连接，合并它们。
• 输出：1

总结

• 通过并查集（Union-Find）结构，我们可以高效地管理站点之间的连接关系。
• 使用路径压缩优化，可以显著减少查找操作的时间复杂度。
• 最终，连通分量的数量即为最少需要发送广播的站点数量。

希望这段详细的注释和讲解能帮助你更好地理解代码的实现逻辑！

三、Java算法源码

以下是 Java 版本的代码详细注释和讲解，帮助理解并查集（Union-Find）的实现以及如何解决广播站问题。

代码结构

1. 主类 Main：负责读取输入并调用逻辑函数。
2. 逻辑函数 getResult：计算最少需要发送广播的站点数量。
3. 并查集类 UnionFindSet：实现并查集的核心功能，包括查找和合并操作。

代码讲解

1. 主类 Main

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    // 读取输入并拆分为字符串数组
    String[] matrix = sc.nextLine().split(",");

    // 调用逻辑函数并输出结果
    System.out.println(getResult(matrix));
  }
}

• 功能：从控制台读取输入，并将其传递给逻辑函数 getResult。
• 输入格式：输入是一行字符串，用逗号分隔，例如 "110,110,001"。
• 处理逻辑：
  • 使用 Scanner 读取输入。
  • 使用 split(",") 将输入按逗号分隔成字符串数组。
  • 调用 getResult 函数计算结果并输出。

2. 逻辑函数 getResult

public static int getResult(String[] matrix) {
  int n = matrix.length;

  // 初始化并查集
  UnionFindSet ufs = new UnionFindSet(n);

  // 遍历矩阵的上三角部分（因为矩阵是对称的）
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      if (matrix[i].charAt(j) == '1') {
        // 如果站点 i 和 j 有连接，则合并它们
        ufs.union(i, j);
      }
    }
  }

  // 返回并查集中的连通分量数量
  return ufs.count;
}

• 功能：计算最少需要发送广播的站点数量。
• 逻辑：
  • 初始化并查集 ufs，大小为 n（站点数量）。
  • 遍历矩阵的上三角部分（因为矩阵是对称的，只需要遍历一半）。
  • 如果 matrix[i].charAt(j) == '1'，表示站点 i 和 j 有连接，调用 ufs.union(i, j) 合并它们。
  • 最终返回并查集中的连通分量数量 ufs.count，即最少需要发送广播的站点数量。

3. 并查集类 UnionFindSet

class UnionFindSet {
  int[] fa; // 父节点数组
  int count; // 连通分量数量

  // 构造函数，初始化并查集
  public UnionFindSet(int n) {
    this.fa = new int[n];
    for (int i = 0; i < n; i++) fa[i] = i; // 初始时每个站点的父节点为自己
    this.count = n; // 初始时每个站点都是独立的
  }

  // 查找 x 的祖先节点（路径压缩优化）
  public int find(int x) {
    if (x != this.fa[x]) {
      // 递归查找祖先节点，并将路径上的所有节点直接指向祖先节点
      this.fa[x] = this.find(this.fa[x]);
      return this.fa[x];
    }
    return x;
  }

  // 合并 x 和 y 所在的集合
  public void union(int x, int y) {
    // 找到 x 和 y 的祖先节点
    int x_fa = this.find(x);
    int y_fa = this.find(y);

    // 如果祖先节点不同，则合并它们
    if (x_fa != y_fa) {
      this.fa[y_fa] = x_fa; // 将 y 的祖先节点指向 x 的祖先节点
      this.count--; // 连通分量数量减 1
    }
  }
}

• 功能：实现并查集的核心功能，包括查找和合并操作。
• 属性：
  • fa：父节点数组，fa[x] 表示站点 x 的父节点。
  • count：连通分量数量，初始时每个站点都是独立的。
• 方法：
  • find(x)：
    • 查找站点 x 的祖先节点。
    • 使用路径压缩优化，将路径上的所有节点直接指向祖先节点，减少后续查找的时间复杂度。
  • union(x, y)：
    • 合并站点 x 和 y 所在的集合。
    • 如果它们的祖先节点不同，则将其中一个祖先节点指向另一个祖先节点，并减少连通分量数量。

代码运行示例

输入 1

110,110,001

• 矩阵：

  ["110", "110", "001"]
  

• 逻辑：
  • 站点 0 和 1 有连接，合并它们。
  • 站点 2 没有连接，独立成一个连通分量。
• 输出：2

输入 2

100,010,001

• 矩阵：

  ["100", "010", "001"]
  

• 逻辑：
  • 所有站点都没有连接，各自独立。
• 输出：3

输入 3

11,11

• 矩阵：

  ["11", "11"]
  

• 逻辑：
  • 站点 0 和 1 有连接，合并它们。
• 输出：1

总结

• 通过并查集（Union-Find）结构，我们可以高效地管理站点之间的连接关系。
• 使用路径压缩优化，可以显著减少查找操作的时间复杂度。
• 最终，连通分量的数量即为最少需要发送广播的站点数量。

希望这段详细的注释和讲解能帮助你更好地理解 Java 版本的实现逻辑！

四、Python算法源码

以下是 Python 版本的代码详细注释和讲解，帮助理解并查集（Union-Find）的实现以及如何解决广播站问题。

代码结构

1. 输入获取：从标准输入读取数据并处理。
2. 并查集类 UnionFindSet：实现并查集的核心功能，包括查找和合并操作。
3. 算法入口函数 getResult：计算最少需要发送广播的站点数量。
4. 算法调用：调用 getResult 函数并输出结果。

代码讲解

1. 输入获取

matrix = input().split(",")

• 功能：从标准输入读取一行数据，并将其按逗号分隔成字符串列表。
• 输入格式：输入是一行字符串，用逗号分隔，例如 "110,110,001"。
• 处理逻辑：
  • 使用 input() 读取输入。
  • 使用 split(",") 将输入按逗号分隔成字符串列表，例如 ["110", "110", "001"]。

2. 并查集类 UnionFindSet

class UnionFindSet:
    def __init__(self, n):
        # 初始化父节点数组，每个站点的父节点初始为自己
        self.fa = [i for i in range(n)]
        # 初始化连通分量数量，初始时每个站点都是独立的
        self.count = n

    # 查找 x 的祖先节点（路径压缩优化）
    def find(self, x):
        if x != self.fa[x]:
            # 递归查找祖先节点，并将路径上的所有节点直接指向祖先节点
            self.fa[x] = self.find(self.fa[x])
            return self.fa[x]
        return x

    # 合并 x 和 y 所在的集合
    def union(self, x, y):
        # 找到 x 和 y 的祖先节点
        x_fa = self.find(x)
        y_fa = self.find(y)

        # 如果祖先节点不同，则合并它们
        if x_fa != y_fa:
            self.fa[y_fa] = x_fa  # 将 y 的祖先节点指向 x 的祖先节点
            self.count -= 1  # 连通分量数量减 1

• 功能：实现并查集的核心功能，包括查找和合并操作。
• 属性：
  • fa：父节点数组，fa[x] 表示站点 x 的父节点。
  • count：连通分量数量，初始时每个站点都是独立的。
• 方法：
  • find(x)：
    • 查找站点 x 的祖先节点。
    • 使用路径压缩优化，将路径上的所有节点直接指向祖先节点，减少后续查找的时间复杂度。
  • union(x, y)：
    • 合并站点 x 和 y 所在的集合。
    • 如果它们的祖先节点不同，则将其中一个祖先节点指向另一个祖先节点，并减少连通分量数量。

3. 算法入口函数 getResult

def getResult(matrix):
    n = len(matrix)

    # 初始化并查集
    ufs = UnionFindSet(n)

    # 遍历矩阵的上三角部分（因为矩阵是对称的）
    for i in range(n):
        for j in range(i + 1, n):
            if matrix[i][j] == "1":
                # 如果站点 i 和 j 有连接，则合并它们
                ufs.union(i, j)

    # 返回并查集中的连通分量数量
    return ufs.count

• 功能：计算最少需要发送广播的站点数量。
• 逻辑：
  • 初始化并查集 ufs，大小为 n（站点数量）。
  • 遍历矩阵的上三角部分（因为矩阵是对称的，只需要遍历一半）。
  • 如果 matrix[i][j] == '1'，表示站点 i 和 j 有连接，调用 ufs.union(i, j) 合并它们。
  • 最终返回并查集中的连通分量数量 ufs.count，即最少需要发送广播的站点数量。

4. 算法调用

print(getResult(matrix))

• 功能：调用 getResult 函数并输出结果。
• 逻辑：
  • 将输入的 matrix 传递给 getResult 函数。
  • 输出计算结果。

代码运行示例

输入 1

110,110,001

• 矩阵：

  ["110", "110", "001"]
  

• 逻辑：
  • 站点 0 和 1 有连接，合并它们。
  • 站点 2 没有连接，独立成一个连通分量。
• 输出：2

输入 2

100,010,001

• 矩阵：

  ["100", "010", "001"]
  

• 逻辑：
  • 所有站点都没有连接，各自独立。
• 输出：3

输入 3

11,11

• 矩阵：

  ["11", "11"]
  

• 逻辑：
  • 站点 0 和 1 有连接，合并它们。
• 输出：1

总结

• 通过并查集（Union-Find）结构，我们可以高效地管理站点之间的连接关系。
• 使用路径压缩优化，可以显著减少查找操作的时间复杂度。
• 最终，连通分量的数量即为最少需要发送广播的站点数量。

希望这段详细的注释和讲解能帮助你更好地理解 Python 版本的实现逻辑！

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

以下是 C 语言和 C++ 版本的代码实现，附带详细的中文注释和讲解，帮助理解并查集（Union-Find）的实现以及如何解决广播站问题。

C 语言版本

代码实现

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

#define MAX_SIZE 10000

/** 并查集定义 **/
typedef struct {
    int *fa; // 父节点数组
    int count; // 连通分量数量
} UFS;

// 初始化并查集
UFS *new_UFS(int n) {
    UFS *ufs = (UFS *) malloc(sizeof(UFS)); // 分配内存
    ufs->fa = (int *) malloc(sizeof(int) * n); // 分配父节点数组内存

    // 初始化父节点数组，每个站点的父节点初始为自己
    for (int i = 0; i < n; i++) {
        ufs->fa[i] = i;
    }

    // 初始化连通分量数量，初始时每个站点都是独立的
    ufs->count = n;

    return ufs;
}

// 查找 x 的祖先节点（路径压缩优化）
int find_UFS(UFS *ufs, int x) {
    if (x != ufs->fa[x]) {
        // 递归查找祖先节点，并将路径上的所有节点直接指向祖先节点
        ufs->fa[x] = find_UFS(ufs, ufs->fa[x]);
        return ufs->fa[x];
    }
    return x;
}

// 合并 x 和 y 所在的集合
void union_UFS(UFS *ufs, int x, int y) {
    // 找到 x 和 y 的祖先节点
    int x_fa = find_UFS(ufs, x);
    int y_fa = find_UFS(ufs, y);

    // 如果祖先节点不同，则合并它们
    if (x_fa != y_fa) {
        ufs->fa[y_fa] = x_fa; // 将 y 的祖先节点指向 x 的祖先节点
        ufs->count--; // 连通分量数量减 1
    }
}

/** 算法逻辑 **/
char matrix[MAX_SIZE][MAX_SIZE]; // 存储输入的矩阵

int main() {
    int n = 0; // 站点数量

    // 读取输入矩阵
    while (scanf("%[^,\n]", matrix[n++]) == 1) {
        if (getchar() != ',') break; // 如果下一个字符不是逗号，则结束输入
    }

    // 初始化并查集
    UFS *ufs = new_UFS(n);

    // 遍历矩阵的上三角部分（因为矩阵是对称的）
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (matrix[i][j] == '1') {
                // 如果站点 i 和 j 有连接，则合并它们
                union_UFS(ufs, i, j);
            }
        }
    }

    // 输出连通分量数量
    printf("%d\n", ufs->count);

    // 释放内存
    free(ufs->fa);
    free(ufs);

    return 0;
}

代码讲解

1. 并查集定义：

   • UFS 结构体包含两个成员：
     • fa：父节点数组，fa[x] 表示站点 x 的父节点。
     • count：连通分量数量，初始时每个站点都是独立的。
   • new_UFS：初始化并查集，分配内存并设置初始值。
   • find_UFS：查找站点 x 的祖先节点，使用路径压缩优化。
   • union_UFS：合并站点 x 和 y 所在的集合。

2. 算法逻辑：

   • 从标准输入读取矩阵数据，存储到 matrix 数组中。
   • 初始化并查集 ufs。
   • 遍历矩阵的上三角部分，合并有连接的站点。
   • 输出连通分量数量 ufs->count。

3. 输入输出示例：

   • 输入：110,110,001
   • 输出：2

C++ 版本

代码实现

#include <iostream>
#include <vector>
using namespace std;

/** 并查集定义 **/
class UnionFindSet {
public:
    vector<int> fa; // 父节点数组
    int count; // 连通分量数量

    // 构造函数，初始化并查集
    UnionFindSet(int n) {
        fa.resize(n);
        for (int i = 0; i < n; i++) {
            fa[i] = i; // 初始时每个站点的父节点为自己
        }
        count = n; // 初始时每个站点都是独立的
    }

    // 查找 x 的祖先节点（路径压缩优化）
    int find(int x) {
        if (x != fa[x]) {
            // 递归查找祖先节点，并将路径上的所有节点直接指向祖先节点
            fa[x] = find(fa[x]);
            return fa[x];
        }
        return x;
    }

    // 合并 x 和 y 所在的集合
    void unionSets(int x, int y) {
        int x_fa = find(x);
        int y_fa = find(y);

        // 如果祖先节点不同，则合并它们
        if (x_fa != y_fa) {
            fa[y_fa] = x_fa; // 将 y 的祖先节点指向 x 的祖先节点
            count--; // 连通分量数量减 1
        }
    }
};

/** 算法逻辑 **/
int main() {
    vector<string> matrix; // 存储输入的矩阵
    string row;

    // 读取输入矩阵
    while (getline(cin, row, ',')) {
        matrix.push_back(row);
    }

    int n = matrix.size(); // 站点数量

    // 初始化并查集
    UnionFindSet ufs(n);

    // 遍历矩阵的上三角部分（因为矩阵是对称的）
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (matrix[i][j] == '1') {
                // 如果站点 i 和 j 有连接，则合并它们
                ufs.unionSets(i, j);
            }
        }
    }

    // 输出连通分量数量
    cout << ufs.count << endl;

    return 0;
}

代码讲解

1. 并查集定义：

   • UnionFindSet 类包含两个成员：
     • fa：父节点数组，fa[x] 表示站点 x 的父节点。
     • count：连通分量数量，初始时每个站点都是独立的。
   • 构造函数：初始化并查集，设置初始值。
   • find：查找站点 x 的祖先节点，使用路径压缩优化。
   • unionSets：合并站点 x 和 y 所在的集合。

2. 算法逻辑：

   • 从标准输入读取矩阵数据，存储到 matrix 向量中。
   • 初始化并查集 ufs。
   • 遍历矩阵的上三角部分，合并有连接的站点。
   • 输出连通分量数量 ufs.count。

3. 输入输出示例：

   • 输入：110,110,001
   • 输出：2

总结

• C 语言和 C++ 版本的实现逻辑基本相同，主要区别在于语法和数据结构的使用。
• 通过并查集（Union-Find）结构，我们可以高效地管理站点之间的连接关系。
• 使用路径压缩优化，可以显著减少查找操作的时间复杂度。
• 最终，连通分量的数量即为最少需要发送广播的站点数量。

希望这段详细的注释和讲解能帮助你更好地理解 C 语言和 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 或监考人员进行反馈。

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