华为OD机试 - 加密算法 - 深度优先搜索dfs（Python/JS/C/C++ 2025 B卷 200分）

于 2025-05-14 08:03:39 发布
阅读量817 收藏 20
点赞数 16
分类专栏： 搬砖工逆袭Java架构师 文章标签： 华为od 深度优先 python javascript 华为OD机试 2025B卷
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/guorui_java/article/details/147939309
版权

在这里插入图片描述

2025B卷华为OD机试统一考试题库清单（持续收录中）以及考点说明（Python/JS/C/C++）。

专栏导读

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

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

一、题目描述

有一种特殊的加密算法，明文为一段数字串，经过密码本查找转换，生成另一段密文数字串。规则如下

  1. 明文为一段数字串由0-9组成
  2. 密码本为数字0-9组成的二维数组
  3. 需要按明文串的数字顺序在密码本里找到同样的数字串，密码本里的数字串是由相邻的单元格数字组成，上下和左右是相邻的，注意:对角线不相邻，同一个单元格的数字不能重复使用。
  4. 每一位明文对应密文即为密码本中找到的单元格所在的行和列序号(序号从0开始)组成的两个数字。如明文第i位Data[i]对应密码本单元格为Book[X][Y]，则明文第i位对应的密文为X Y，X和Y之间用空格隔开。如果有多条密文，返回字符序最小的密文。如果密码本无法匹配，返回"error".

请你设计这个加密程序。

示例 1:

密码本:

{0,0,2},
{1,3,4},
{6,6,4}

明文"3"，密文"1 1"

示例 2:

密码本:

{0,0,2},
{1,3,4},
{6,6,4}

明文"0 3",密文"0 1 1 1"

二、输入描述

第一行输入1个正整数N，代表明文的长度(1 <= N <= 9)

第二行输入N个明文数字组成的序列Data[i](整数，0 <= Data[i] <= 9)

第三行输入1个正整数M，(1 <= M <= 9)

接下来输入一个M*M的矩阵代表密码本Book[i][i]，(整数，0 <= Book[i][i] <= 9)

三、输出描述

如明文 第i位Data[i]对应密码本单元格为Book[i][j]，则明文第i位对应的密文为X Y，X和Y之间用空格隔开。如果有多条密文，返回字符序最小的密文。如果密码本无法匹配，返回"error"。

四、测试用例

测试用例1

1、输入

1
3
3
0 0 2
1 3 4
6 6 4

2、输出

1 1

3、说明

明文只有一个数字"3"，在密码本中位置为(1,1)，所以密文为"1 1"。

测试用例2

1、输入

2
5 7
3
0 0 2
1 3 4
6 6 5

2、输出

error

3、说明

明文为"5 7"，在密码本中可以找到"5"，但没有与"5"相邻的"7"，所以无法找到匹配路径，返回"error"。

五、解题思路

1、解题思路

首先在密码本中找到所有与明文第一个数字匹配的单元格作为起点。
从每个起点开始，使用DFS搜索与明文匹配的完整路径。
对于每个有效路径，构建对应的密文（单元格坐标序列）。
如果找到多个可能的密文，按字典序排序并返回最小的一个。
如果没有找到匹配的路径，返回"error"。

2、数据结构和算法选择

二维数组（密码本）：用于存储密码本的数据。

深度优先搜索(DFS)：用于在密码本中寻找匹配明文的路径。

回溯算法：在DFS中使用回溯来尝试所有可能的路径。

3、为什么采用这些数据结构和算法

二维数组：密码本本身就是一个MxM的矩阵，使用二维数组最为直观和高效。

深度优先搜索(DFS)：

  1. 适合在网格中寻找路径的问题。
  2. 能够探索所有可能的方向（上、右、下、左）。
  3. 结合回溯可以穷举所有可能的路径。

回溯算法：当发现当前路径不满足条件时，可以回退到上一步，尝试其他可能的路径。对于搜索所有可能解的问题非常有效。

六、Python算法源码

def main():
    # 读取明文长度 N
    N = int(input())
    
    # 读取明文数字序列
    plaintext = list(map(int, input().split()))
    
    # 读取密码本大小 M
    M = int(input())
    
    # 读取密码本
    codeBook = []
    for _ in range(M):
        codeBook.append(list(map(int, input().split())))
    
    # 四个方向：上、右、下、左
    dr = [-1, 0, 1, 0]  # 行变化
    dc = [0, 1, 0, -1]  # 列变化
    
    # 找到所有可能的密文
    def findAllCiphertexts():
        allCiphertexts = []
        
        # 遍历密码本中的每一个单元格作为起始点
        for i in range(M):
            for j in range(M):
                # 如果起始单元格匹配明文的第一个数字
                if codeBook[i][j] == plaintext[0]:
                    # 记录已访问的单元格
                    visited = [[False for _ in range(M)] for _ in range(M)]
                    visited[i][j] = True
                    
                    # 记录当前路径
                    path = [(i, j)]
                    
                    # 开始深度优先搜索
                    dfs(1, i, j, visited, path, allCiphertexts)
        
        return allCiphertexts
    
    # 使用DFS搜索匹配明文的路径
    def dfs(index, r, c, visited, path, allCiphertexts):
        # 如果已经匹配了整个明文
        if index == len(plaintext):
            # 构建密文字符串
            ciphertext = ""
            for i in range(len(path)):
                coord = path[i]
                ciphertext += str(coord[0]) + " " + str(coord[1])
                if i < len(path) - 1:
                    ciphertext += " "
            # 添加到密文列表
            allCiphertexts.append(ciphertext)
            return
        
        # 尝试四个方向的相邻单元格
        for d in range(4):
            nr = r + dr[d]
            nc = c + dc[d]
            
            # 检查新单元格是否在密码本范围内，且未被访问过，且匹配明文当前字符
            if 0 <= nr < M and 0 <= nc < M and not visited[nr][nc] and codeBook[nr][nc] == plaintext[index]:
                # 标记为已访问
                visited[nr][nc] = True
                # 添加到当前路径
                path.append((nr, nc))
                
                # 继续搜索下一个字符
                dfs(index + 1, nr, nc, visited, path, allCiphertexts)
                
                # 回溯
                path.pop()
                visited[nr][nc] = False
    
    allCiphertexts = findAllCiphertexts()
    
    if not allCiphertexts:
        # 如果没有找到匹配的密文，返回 "error"
        print("error")
    else:
        # 按字典序排序，返回最小的密文
        allCiphertexts.sort()
        print(allCiphertexts[0])

if __name__ == "__main__":
    main()

七、JavaScript算法源码

// 使用Node.js运行JavaScript代码，通过process.stdin和process.stdout进行输入输出
const readline = require('readline');

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

const lines = [];
let lineIndex = 0;

rl.on('line', (line) => {
    lines.push(line);
});

rl.on('close', () => {
    // 读取明文长度 N
    const N = parseInt(lines[lineIndex++]);
    
    // 读取明文数字序列
    const plaintext = lines[lineIndex++].split(' ').map(Number);
    
    // 读取密码本大小 M
    const M = parseInt(lines[lineIndex++]);
    
    // 读取密码本
    const codeBook = [];
    for (let i = 0; i < M; i++) {
        codeBook.push(lines[lineIndex++].split(' ').map(Number));
    }
    
    // 四个方向：上、右、下、左
    const dr = [-1, 0, 1, 0];  // 行变化
    const dc = [0, 1, 0, -1];  // 列变化
    
    // 找到所有可能的密文
    function findAllCiphertexts() {
        const allCiphertexts = [];
        
        // 遍历密码本中的每一个单元格作为起始点
        for (let i = 0; i < M; i++) {
            for (let j = 0; j < M; j++) {
                // 如果起始单元格匹配明文的第一个数字
                if (codeBook[i][j] === plaintext[0]) {
                    // 记录已访问的单元格
                    const visited = Array(M).fill().map(() => Array(M).fill(false));
                    visited[i][j] = true;
                    
                    // 记录当前路径
                    const path = [[i, j]];
                    
                    // 开始深度优先搜索
                    dfs(1, i, j, visited, path, allCiphertexts);
                }
            }
        }
        
        return allCiphertexts;
    }
    
    // 使用DFS搜索匹配明文的路径
    function dfs(index, r, c, visited, path, allCiphertexts) {
        // 如果已经匹配了整个明文
        if (index === plaintext.length) {
            // 构建密文字符串
            let ciphertext = "";
            for (let i = 0; i < path.length; i++) {
                const coord = path[i];
                ciphertext += coord[0] + " " + coord[1];
                if (i < path.length - 1) {
                    ciphertext += " ";
                }
            }
            // 添加到密文列表
            allCiphertexts.push(ciphertext);
            return;
        }
        
        // 尝试四个方向的相邻单元格
        for (let d = 0; d < 4; d++) {
            const nr = r + dr[d];
            const nc = c + dc[d];
            
            // 检查新单元格是否在密码本范围内，且未被访问过，且匹配明文当前字符
            if (nr >= 0 && nr < M && nc >= 0 && nc < M && !visited[nr][nc] && codeBook[nr][nc] === plaintext[index]) {
                // 标记为已访问
                visited[nr][nc] = true;
                // 添加到当前路径
                path.push([nr, nc]);
                
                // 继续搜索下一个字符
                dfs(index + 1, nr, nc, visited, path, allCiphertexts);
                
                // 回溯
                path.pop();
                visited[nr][nc] = false;
            }
        }
    }
    
    const allCiphertexts = findAllCiphertexts();
    
    if (allCiphertexts.length === 0) {
        // 如果没有找到匹配的密文，返回 "error"
        console.log("error");
    } else {
        // 按字典序排序，返回最小的密文
        allCiphertexts.sort();
        console.log(allCiphertexts[0]);
    }
});

八、C算法源码

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

// 四个方向：上、右、下、左
int dr[4] = {-1, 0, 1, 0};  // 行变化
int dc[4] = {0, 1, 0, -1};  // 列变化

// 密文信息结构体
typedef struct {
    char* text;
} Ciphertext;

// 路径信息结构体
typedef struct {
    int* row;
    int* col;
    int size;
    int capacity;
} Path;

// 初始化路径
Path* createPath(int capacity) {
    Path* path = (Path*)malloc(sizeof(Path));
    path->row = (int*)malloc(sizeof(int) * capacity);
    path->col = (int*)malloc(sizeof(int) * capacity);
    path->size = 0;
    path->capacity = capacity;
    return path;
}

// 释放路径内存
void freePath(Path* path) {
    free(path->row);
    free(path->col);
    free(path);
}

// 添加坐标到路径
void addToPath(Path* path, int r, int c) {
    if (path->size >= path->capacity) {
        path->capacity *= 2;
        path->row = (int*)realloc(path->row, sizeof(int) * path->capacity);
        path->col = (int*)realloc(path->col, sizeof(int) * path->capacity);
    }
    path->row[path->size] = r;
    path->col[path->size] = c;
    path->size++;
}

// 从路径中移除最后一个坐标
void removeLastFromPath(Path* path) {
    if (path->size > 0) {
        path->size--;
    }
}

// 构建密文字符串
char* buildCiphertext(Path* path) {
    char* ciphertext = (char*)malloc(path->size * 10); // 足够大的空间
    ciphertext[0] = '\0';
    
    for (int i = 0; i < path->size; i++) {
        char buffer[10];
        sprintf(buffer, "%d %d", path->row[i], path->col[i]);
        strcat(ciphertext, buffer);
        if (i < path->size - 1) {
            strcat(ciphertext, " ");
        }
    }
    
    return ciphertext;
}

// 比较两个密文字符串
int compareCiphertexts(const void* a, const void* b) {
    return strcmp((*(Ciphertext*)a).text, (*(Ciphertext*)b).text);
}

// DFS搜索匹配明文的路径
void dfs(int* plaintext, int plaintext_len, int** codeBook, int M, int index, int r, int c, bool** visited, Path* path, Ciphertext** allCiphertexts, int* ciphertext_count, int* capacity) {
    // 如果已经匹配了整个明文
    if (index == plaintext_len) {
        // 构建密文字符串
        char* ciphertext = buildCiphertext(path);
        
        // 添加到密文列表
        if (*ciphertext_count >= *capacity) {
            *capacity *= 2;
            *allCiphertexts = (Ciphertext*)realloc(*allCiphertexts, sizeof(Ciphertext) * (*capacity));
        }
        (*allCiphertexts)[*ciphertext_count].text = ciphertext;
        (*ciphertext_count)++;
        
        return;
    }
    
    // 尝试四个方向的相邻单元格
    for (int d = 0; d < 4; d++) {
        int nr = r + dr[d];
        int nc = c + dc[d];
        
        // 检查新单元格是否在密码本范围内，且未被访问过，且匹配明文当前字符
        if (nr >= 0 && nr < M && nc >= 0 && nc < M && !visited[nr][nc] && codeBook[nr][nc] == plaintext[index]) {
            // 标记为已访问
            visited[nr][nc] = true;
            // 添加到当前路径
            addToPath(path, nr, nc);
            
            // 继续搜索下一个字符
            dfs(plaintext, plaintext_len, codeBook, M, index + 1, nr, nc, visited, path, allCiphertexts, ciphertext_count, capacity);
            
            // 回溯
            removeLastFromPath(path);
            visited[nr][nc] = false;
        }
    }
}

// 找到所有可能的密文
Ciphertext* findAllCiphertexts(int* plaintext, int plaintext_len, int** codeBook, int M, int* ciphertext_count) {
    int capacity = 100;
    Ciphertext* allCiphertexts = (Ciphertext*)malloc(sizeof(Ciphertext) * capacity);
    *ciphertext_count = 0;
    
    // 遍历密码本中的每一个单元格作为起始点
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < M; j++) {
            // 如果起始单元格匹配明文的第一个数字
            if (codeBook[i][j] == plaintext[0]) {
                // 记录已访问的单元格
                bool** visited = (bool**)malloc(sizeof(bool*) * M);
                for (int k = 0; k < M; k++) {
                    visited[k] = (bool*)calloc(M, sizeof(bool));
                }
                visited[i][j] = true;
                
                // 记录当前路径
                Path* path = createPath(plaintext_len);
                addToPath(path, i, j);
                
                // 开始深度优先搜索
                dfs(plaintext, plaintext_len, codeBook, M, 1, i, j, visited, path, &allCiphertexts, ciphertext_count, &capacity);
                
                // 释放内存
                freePath(path);
                for (int k = 0; k < M; k++) {
                    free(visited[k]);
                }
                free(visited);
            }
        }
    }
    
    return allCiphertexts;
}

int main() {
    // 读取明文长度 N
    int N;
    scanf("%d", &N);
    
    // 读取明文数字序列
    int* plaintext = (int*)malloc(sizeof(int) * N);
    for (int i = 0; i < N; i++) {
        scanf("%d", &plaintext[i]);
    }
    
    // 读取密码本大小 M
    int M;
    scanf("%d", &M);
    
    // 读取密码本
    int** codeBook = (int**)malloc(sizeof(int*) * M);
    for (int i = 0; i < M; i++) {
        codeBook[i] = (int*)malloc(sizeof(int) * M);
        for (int j = 0; j < M; j++) {
            scanf("%d", &codeBook[i][j]);
        }
    }
    
    // 找到所有可能的密文
    int ciphertext_count;
    Ciphertext* allCiphertexts = findAllCiphertexts(plaintext, N, codeBook, M, &ciphertext_count);
    
    if (ciphertext_count == 0) {
        // 如果没有找到匹配的密文，返回 "error"
        printf("error\n");
    } else {
        // 按字典序排序，返回最小的密文
        qsort(allCiphertexts, ciphertext_count, sizeof(Ciphertext), compareCiphertexts);
        printf("%s\n", allCiphertexts[0].text);
    }
    
    // 释放内存
    for (int i = 0; i < ciphertext_count; i++) {
        free(allCiphertexts[i].text);
    }
    free(allCiphertexts);
    
    for (int i = 0; i < M; i++) {
        free(codeBook[i]);
    }
    free(codeBook);
    free(plaintext);
    
    return 0;
}

九、C++算法源码

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>

using namespace std;

// 四个方向：上、右、下、左
const int dr[4] = {-1, 0, 1, 0};  // 行变化
const int dc[4] = {0, 1, 0, -1};  // 列变化

// 使用DFS搜索匹配明文的路径
void dfs(const vector<int>& plaintext, const vector<vector<int>>& codeBook, int M, int index, int r, int c, 
         vector<vector<bool>>& visited, vector<pair<int, int>>& path, vector<string>& allCiphertexts) {
    // 如果已经匹配了整个明文
    if (index == plaintext.size()) {
        // 构建密文字符串
        string ciphertext = "";
        for (int i = 0; i < path.size(); i++) {
            ciphertext += to_string(path[i].first) + " " + to_string(path[i].second);
            if (i < path.size() - 1) {
                ciphertext += " ";
            }
        }
        // 添加到密文列表
        allCiphertexts.push_back(ciphertext);
        return;
    }
    
    // 尝试四个方向的相邻单元格
    for (int d = 0; d < 4; d++) {
        int nr = r + dr[d];
        int nc = c + dc[d];
        
        // 检查新单元格是否在密码本范围内，且未被访问过，且匹配明文当前字符
        if (nr >= 0 && nr < M && nc >= 0 && nc < M && !visited[nr][nc] && codeBook[nr][nc] == plaintext[index]) {
            // 标记为已访问
            visited[nr][nc] = true;
            // 添加到当前路径
            path.push_back({nr, nc});
            
            // 继续搜索下一个字符
            dfs(plaintext, codeBook, M, index + 1, nr, nc, visited, path, allCiphertexts);
            
            // 回溯
            path.pop_back();
            visited[nr][nc] = false;
        }
    }
}

// 找到所有可能的密文
vector<string> findAllCiphertexts(const vector<int>& plaintext, const vector<vector<int>>& codeBook, int M) {
    vector<string> allCiphertexts;
    
    // 遍历密码本中的每一个单元格作为起始点
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < M; j++) {
            // 如果起始单元格匹配明文的第一个数字
            if (codeBook[i][j] == plaintext[0]) {
                // 记录已访问的单元格
                vector<vector<bool>> visited(M, vector<bool>(M, false));
                visited[i][j] = true;
                
                // 记录当前路径
                vector<pair<int, int>> path;
                path.push_back({i, j});
                
                // 开始深度优先搜索
                dfs(plaintext, codeBook, M, 1, i, j, visited, path, allCiphertexts);
            }
        }
    }
    
    return allCiphertexts;
}

int main() {
    // 读取明文长度 N
    int N;
    cin >> N;
    
    // 读取明文数字序列
    vector<int> plaintext(N);
    for (int i = 0; i < N; i++) {
        cin >> plaintext[i];
    }
    
    // 读取密码本大小 M
    int M;
    cin >> M;
    
    // 读取密码本
    vector<vector<int>> codeBook(M, vector<int>(M));
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < M; j++) {
            cin >> codeBook[i][j];
        }
    }
    
    // 找到所有可能的密文
    vector<string> allCiphertexts = findAllCiphertexts(plaintext, codeBook, M);
    
    if (allCiphertexts.empty()) {
        // 如果没有找到匹配的密文，返回 "error"
        cout << "error" << endl;
    } else {
        // 按字典序排序，返回最小的密文
        sort(allCiphertexts.begin(), allCiphertexts.end());
        cout << allCiphertexts[0] << endl;
    }
    
    return 0;
}

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

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

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

在这里插入图片描述

【华为OD机考真题】- 特殊的加密算法(C卷-100分)（Java）
**My Coding Family**
03-24 959
🔔本文收录于「2025华为OD机试真题(Java版)」专栏，手把手带你零基础教学华为OD机试。本题集提供最优题解思路，解题步骤，代码解析，复杂度分析及最优题解源码等，支持多语言题解，助你轻松拿捏OD机考，一举上岸！安利大家关注&&收藏&&订阅！题库正在疯狂收录中，up！up！up！！ 🚫提醒：拒绝一切代考/替考，违法必究！本人所写题库均搜集于互联网。    💗订阅福利：一次订阅，可永久免费阅读，提供在线答疑解惑，后续题库更新皆可阅读使用！
华为OD机试 - 特殊的加密算法 - 深度优先搜索DFS（Python/JS/C/C++ 2024 D卷 200分）
学Java，找哪吒
09-09 842
每一题都有详细的答题思路、详细的代码注释，发现新题目，随时更新，全天CSDN在线答疑。
华为OD机试（含B卷）真题2023 算法分类版，58道20个算法分类，如果距离机考时间不多了，就看这个吧，稳稳的
学Java，找哪吒
08-08 1万+
我觉得可以按照“算法和数据结构”去刷，把华为OD机试涉及到的“算法和数据结构”列出来，一个算法刷10道题，那我岂不是无敌了？后面是为大家 精心挑选的华为OD机试题单，并根据题目知识点的类型分好了类别，大家可以根据每个知识点，进行有针对性的刷题。很多小伙伴问我，华为OD机试算法题太多了，知识点繁杂，如何刷题更有效率呢？下面是我花了一天时间整理的 算法和数据结构的知识结构，大家可以看看。首先，了解算法和数据结构有哪些知识点，在后面的刷题中有 大局观。迪杰斯特拉Dijkstra。回溯法（宽度优选算法）
刷了3个月的华为OD算法题，刷出感觉了，如洁柔般丝滑，文末送《漫画算法2：小灰的算法进阶》
学Java，找哪吒
08-13 5216
我的od同事有7年的ios开发经验，是从隔壁某个体面的硬件大厂跳槽过来的，因为工作经验丰富，反而成为了我和一个正式员工（应届）的老师。如果我没法转正，那么我应该华为校招的正式岗位也过不了。本书是《漫画算法：小灰的算法之旅》的续作，通过主人公小灰的心路历程，用漫画的形式讲述了多个数据结构、算法及复杂多变的算法面试题目。而行业内的人我稍微解释一下他们也能理解，行业内还是看你的技术的，我还是非常肯定我自己的专业实力的。对于我的朋友，行业外的肯定不会认可我的本科，但是我直接笼统地说我在华为工作，外行便会肃然起敬。
2023年华为笔试面试机考真题100道（C/C++语言）
不秃头的程序猿Gabriel的博客
07-07 3万+
华为面试 机考 C语言
HW OD笔试三个算法题(提前一小时满分通过)
HumorChen的博客
09-16 7553
由于笔试时需要退出其他软件录制屏幕开启摄像头，因此原题只根据回忆写出 第一题 M个数求最大的N个数和最小的N个数的和 题目 在提供的M个数里找最大的N个和最小的N个的和，需要自己去重，最大数集合和最小数集合有重合的则返回-1 输入 第一行是数组元素个数M，第二行是数组里的数字，每个数字用空格隔开，第三个数字是N 输入 6 2 3 1 5 12 7 2 输出 22 最大的2个数是 12 7，最小的两个数是1 2，则输出 12+7+1+2=22 输入 4 1 7 1 2 2 2 输出 -1 最大的2个.
常见算法题（包括华为机试题）
zhang434的专栏
04-01 2991
一、维护O(1)时间查找最大元素的栈 问题描述：一个栈stack，具有push和pop操作，其时间复杂度皆为O(1)。设计算法max操作， 求栈中的最大值，该操作的时间复杂度也要求为O(1)。 可以修改栈的存储方式，push，pop的操作，但是要保证O(1)的时间复杂度，空间时间复杂 度无要求。 可以创建一个类，类里有两个栈，一个栈S维持正常的push、pop
华为OD机试2025B卷统一考试题库清单（持续收录中）以及考点说明（Python/JS/C/C++）
学Java，找哪吒
09-25 1万+
刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释发现新题目，随时更新。
2025华为OD机试备考攻略 以及最新题库目录分值说明 + 考点说明+在线OJ
热门推荐
算法大师！
03-18 42万+
OD，全称(Outsourcing Dispacth)模式，目前华为和德科联合招聘的简称。华为社招基本都是OD招聘，17级以下都是OD模式（13-17）。
华为OD机试-特殊的加密算法（Java/Python/C++）
shen198899的博客
04-30 649
华为OD机试-特殊的加密算法（Java/Python/C++）：有一种特殊的加密算法，明文为一段数字串，经过密码本查找转换，生成另一段密文数字串。规则如下1.明文为一段数字串由0-9组成2.密码本为数字0-9组成的二维数组3.需要按明文串的数字顺序在密码本里找到同样的数字串，密码本里的数字串是由相邻的单元格数字组成，上下和左右是相邻的，注意:对角线不相邻，同一个单元格的数字不能重复使用。4.每一位明文对应密文即为密码本中找到的单元格所在的行和列序号(序号从0开始)组成的两个数字。
2024华为OD机试题库-(A卷+B卷+C卷+D卷+E)-(JAVA、Python、C++)
goldarmour的博客
03-28 4万+
博主是一名资深后端开发人员，精通C++，Python，Java，乐于分享面试经验，已帮助千余名同学通过OD机考！这些题目博主每一道都刷了至少两遍，每一行代码都蕴含了博主从业以来所积累的所有经验和技巧，可谓干货满满！
华为OD算法题汇总
Derek7117的博客
07-16 883
一些算法题
华为od的一些算法题
weixin_45483161的博客
07-04 2863
输入描述：输入一个整数参数M 输出描述：如果输入参数M小于等于1或者大于等于100，输出“ERROR!”；否则按照原先的编号从小到大的顺序，以英文逗号分割输出编号字符串 示例1： 输入 输出 3 58,91 编写函数，计算输入中单词的出现次数。 Ⅰ按次数降序输出， Ⅱ相同次数的按字母顺序升序排序。 New to Python or choosing between Python 2 and Python 3? Read Python 2 or Python 3 正确结果为： Python : 5 2 : 2
2024华为OD机试真题【区间交叠/贪心算法】【Python Java C++】
wtswts1232的博客
04-17 1万+
然后遍历排序后的线段，每遍历到一个线段，将其作为开始的线段，再找出后面的线段中左端点小于等于当前线段的右端点的线段们，找出这些线段中右端点最大的一个线段。反复重复上一步，直到覆盖完整个长度为m的区间，就能得到最少的线段数。给定坐标轴上的一组线段，线段的起点和终点均为整数并且长度不小于1，请你从中找到最少数量的线段，这些线段可以覆盖住所有线段。第一行输入为所有线段的数量，不超过10000，后面每行表示一条线段，格式为”x,y”，x和y 分别表示起点和终点，取值范围是[-10^5 ，10^5]。
华为机考真题
qq_51118755的博客
09-25 1150
某通信系统持续向外发送报文，使用数组 nums 保存 � 个最近发送的报文，用于在报文未达到对端的情况下重发。报文使用序号 �� 表示，序号 �� 按照报文发送顺序从小到大排序，相邻报文 �� 不完全连续且有可能相同。报文使用循环覆盖的方式保存，即 nums 数组填满后，从头开始保存新的报文。假设需要重发序号为 �� 的报文。请找出序号为 �� 的报文在数组中的开始位置和结束位置。
算法题--华为od机试考试（整数对最小和、素数之积、找城市）
AIWWY的博客
06-22 1452
例如上图（示例2），我们通过上面遍历方法得出的数组为[1,2,3,2,4,5,4,6,4,2,1]。然后我们将这个数组形成一个环，这样对每个数进行切割后得到的数组内去重后就是一个城市群，例如对2进行切割，可以拿到[1],[3],[4,5,4,6,4]，[1]然后由于是环，所以第一个和最后一个是一组，最后去重后就是分组结果[1][3][4,5,6]，所以可以得到DPi为3即取[4,5,6]。arr[i][j]表示的为一对元素的和，将二维数组拍平，然后按升序排列，取前k位的和即为满足要求的最小和。
华为OD机试 - 加密算法 - 深度优先搜索dfs（Java 2025 B卷 200分）
最新发布
学Java，找哪吒
05-14 567
华为OD机试 2025B卷题库疯狂收录中，刷题。
【华为机考题库学习】--算法篇(更新中……)
用余生去守护的博客
07-12 2480
写作离不开丰富的学识，即知识储备。知识积累多了，思路就会开阔，写起文章来就会得心应手、左右逢源。
【华为机试】死记硬背没思路？一般人我劝你还是算了吧
学Java，找哪吒
06-03 1万+
华为机试有三道题，第一道和第二道属于简单题，分值为100分，第三道为困难题，分值为200分，总分400分，150分钟考试时间
华为OD机试真题e卷------分糖果python
02-15
### 华为OD机试分糖果问题的Python解题思路 #### 问题描述 小明从糖果盒中随意抓取一定数量的糖果，每次可以执行三种操作之一：取出一半糖果并舍去余数；如果当前糖果数目为奇数，则可以从盒子中再拿一个糖果或将手里的一个糖果放回去。目标是最少经过几次这样的操作能够使手中的糖果变为一颗。 为了达到这个目的，采用贪心策略来解决问题[^3]。具体来说，在每一步都尽可能快速地减少糖果的数量直到只剩下一颗为止。当遇到奇数个糖果时，优先考虑加一而不是减一，因为这样可以在下一轮更有效地通过除以2的方式大量削减糖果总数。 #### 贪婪算法分析 对于任意正整数n表示初始糖果数： - 如果 n 是偶数，则直接将其除以2； - 若 n 为奇数，则判断 (n+1)/2 和 (n−1)/2 的大小关系，选择较小的那个作为下一步的结果，这是因为我们希望更快接近1。 这种做法基于这样一个事实——当我们面对两个连续的奇数值时，较大的那个总是可以通过增加1变成一个小得多的新值（即其半数），而较小的一个则需要两次操作才能完成同样的效果(先减后除)[^4]。 #### Python代码实现 下面给出了解决上述问题的具体Python程序： ```python def min_steps_to_one(n): steps = 0 while n != 1: if n % 2 == 0: n //= 2 elif ((n + 1) // 2) < ((n - 1) // 2): n += 1 else: n -= 1 steps += 1 return steps if __name__ == "__main__": candy_count = int(input().strip()) print(min_steps_to_one(candy_count)) ``` 此函数接收一个参数`n`代表起始的糖果数量，并返回将这些糖果减少到只有一个所需的最小步数。主程序部分读入用户输入的数据并调用该方法打印最终结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

哪 吒

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

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

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

打赏作者

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

抵扣说明：

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

余额充值