【双机位A卷】华为OD笔试之【模拟】双机位A-螺旋数字矩阵【Py/Java/C++/C/JS/Go六种语言】【欧弟算法】全网注释最详细分类最全的华子OD真题题解

于 2025-10-10 22:26:25 发布
阅读量611 收藏 20
点赞数 22
CC 4.0 BY-SA版权
分类专栏： # 模拟 文章标签： 算法 华为od 矩阵 javascript c++ java python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48157259/article/details/152957077

可上 欧弟OJ系统 练习华子OD、大厂真题
绿色聊天软件戳 od1441了解算法冲刺训练（备注【CSDN】否则不通过）

文章目录

相关推荐阅读

题目练习网址：【模拟】双机位A-螺旋数字矩阵

题目描述与示例

题目描述

疫情期间，小明隔离在家，百无聊赖，在纸上写数字玩。

他发明了一种写法：给出数字个数n和行数m (0 < n < 999，0 < m < 999)，从左上角的1开始，按照顺时针螺旋向内写方式，依次写出1, 2, 3, ..., n，最终形成一个m行矩阵。

小明对这个矩阵有些要求：

  1. 每行数字的个数一样多
  2. 列的数量尽可能少
  3. 填充数字时优先填充外部
  4. 数字不够时，使用单个*号占位

输入描述

两个整数，空格隔开，依次表示n、m

输出描述

符合要求的唯一短阵

示例

输入

9 4

输出

1 2 3
* * 4
9 * 5
8 7 6

解题思路

注意，本题和LeetCode54、螺旋矩阵非常类似。

本题既可以用迭代方法也可以用递归方法完成。本题解主要介绍递归方法。

题目要求矩阵列数尽可能少，使用向上取整，很容易算出来最小的列数为c = ceil(n / m)。

注意到每次填充都优先填充矩阵的最外圈，比如对于5*5的矩阵，初始化均用*填充

* * * * *
* * * * *
* * * * *
* * * * *
* * * * *

假设需要填充21个数，那么第一圈会螺旋式地填充如下

1 2 3 4 5
16 * * * 6
15 * * * 7
14 * * * 8
13 12 11 10 9

中间剩余一个(5-2)*(5-2) = 3*3的未填充矩阵，那么可以从17开始继续螺旋式地填充第二层矩阵，直到到达21，即

1 2 3 4 5
16 17 18 19 6
15 * * 20 7
14 * * 21 8
13 12 11 10 9

显然每一次填充，都是从未填充矩阵的左上角开始填充其外层，直到填充完毕或到达规定数字。

因此可以使用递归来完成上述过程。

首先我们需要初始化一个均由"*"填充的m``*``c的二维矩阵ans。

# 计算列数c，为n除以m后向上取整
c = ceil(n / m)
# 初始化答案螺旋数组，先用"*"填充
ans = [["*"] * c for _ in range(m)]

在递归过程中，我们需要

  • 四个参数start_i, end_i, start_j, end_j分别为子矩阵的起始、终止的i和j下标。即
      start_j       end_j
            ↓       ↓
start_i →   * * * * *
            * * * * *
            * * * * *
            * * * * *
end_i   →   * * * * *
  • cur_num为未填充子矩阵左上角的第一个数
  • 填充结束的终止数字n

以填充子矩阵的上边界为例，我们需要固定start_i，从左往右（从start_j到end_j）遍历j。

在遍历过程中，我们需要把ans[start_i][j]修改为str(cur_num)，同时增加cur_num，且一旦发现cur_num大于n，则可以直接退出函数。代码为

def help(ans, start_i, end_i, start_j, end_j, cur_num, n):
    pass
    # 未填充矩阵的上边界：从左往右，固定start_i，正序遍历j
    for j in range(start_j, end_j):
        ans[start_i][j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    pass

同理我们可以构建出填充子矩阵其他遍历方向的代码

def help(ans, start_i, end_i, start_j, end_j, cur_num, n):
    pass
    # 未填充矩阵的上边界：从左往右，固定start_i，正序遍历j
    for j in range(start_j, end_j):
        ans[start_i][j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的右边界：从上往下，固定end_j，正序遍历i
    for i in range(start_i, end_i):
        ans[i][end_j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的下边界：从右往左，固定end_i，逆序遍历j
    for j in range(end_j, start_j, -1):
        ans[end_i][j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的左边界：从下往上，固定start_j，逆序遍历j
    for i in range(end_i, start_i, -1):
        ans[i][start_j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    pass

在所有遍历和边界填充完成之后，我们需要进行递归函数的调用。

注意到在下一层递归中，四个边界分别变成了start_i+1, end_i-1, start_j+1, end_j-1。即代码为

def help(ans, start_i, end_i, start_j, end_j, cur_num, n):
    pass
    # 未填充矩阵的上边界：从左往右，固定start_i，正序遍历j
    for j in range(start_j, end_j):
        ans[start_i][j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的右边界：从上往下，固定end_j，正序遍历i
    for i in range(start_i, end_i):
        ans[i][end_j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的下边界：从右往左，固定end_i，逆序遍历j
    for j in range(end_j, start_j, -1):
        ans[end_i][j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的左边界：从下往上，固定start_j，逆序遍历i
    for i in range(end_i, start_i, -1):
        ans[i][start_j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 对未填充数组进行递归
    # start_i, end_i, start_j, end_j需要修改
    help(ans, start_i+1, end_i-1, start_j+1, end_j-1, cur_num, n)

除此之外，还需要考虑一种特殊情况。

如果遍历区间不存在，则不会进入四个for循环中的任意一个，会持续进行递归，导致编译栈溢出。

这种情况就是当n为某个奇数的平方且c = m = sqrt(n)的时候会出现。

譬如填充5*5的矩阵且n = 25，最中间那个数字会出现的情况。

我们还需要额外判断这种条件，将最中间的数字填充上并退出递归即可。修改代码为

def help(ans, start_i, end_i, start_j, end_j, cur_num, n):
    # 如果不存在遍历区间，则不会进入下面四个for循环中的任意一个
    # 会持续进行递归，导致编译栈溢出
    # 这种情况就是当n为某个奇数的平方且c = m = sqrt(n)的时候会出现
    # 譬如填充5*5的矩阵且n = 25，最中间那个数字会出现的情况
    # 额外判断这种条件，将最中间的数字填充上并退出递归即可
    if start_i == end_i and start_j == end_j:
        ans[start_i][start_j] = cur_num
        return
    # 未填充矩阵的上边界：从左往右，固定start_i，正序遍历j
    for j in range(start_j, end_j):
        ans[start_i][j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的右边界：从上往下，固定end_j，正序遍历i
    for i in range(start_i, end_i):
        ans[i][end_j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的下边界：从右往左，固定end_i，逆序遍历j
    for j in range(end_j, start_j, -1):
        ans[end_i][j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的左边界：从下往上，固定start_j，逆序遍历j
    for i in range(end_i, start_i, -1):
        ans[i][start_j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 对未填充数组进行递归
    # start_i, end_i, start_j, end_j需要修改
    help(ans, start_i+1, end_i-1, start_j+1, end_j-1, cur_num, n)

剩下的内容就是递归入口的调用了。

分别对start_i, end_i, start_j, end_j传入0, m-1, 0, c-1即可。

cur_num则传入第一个需要填充的数字1。即

# 递归入口：start_i, end_i, start_j, end_j
# 分别传入0, m-1, 0, c-1
help(ans, 0, m-1, 0, c-1, 1, n)

代码

Python

# 欢迎来到「欧弟算法 - 华为OD全攻略」,收录华为OD题库、面试指南、八股文与学员案例！
# 地址：https://www.odalgo.com
# 华为OD机试刷题网站：https://www.algomooc.com
# 添加微信 278166530 获取华为 OD 笔试真题题库和视频

# 题目：【模拟】2024D/2024E/2025A/2025B/双机位A-螺旋矩阵
# 分值：100
# 作者：许老师-闭着眼睛学数理化
# 算法：模拟/递归
# 代码看不懂的地方，请直接在群上提问


from math import ceil

# 递归函数
# ans为答案螺旋矩阵
# start_i, end_i, start_j, end_j分别为子矩阵的起始、终止的i和j下标
# cur_num为未填充子矩阵左上角的第一个数
# n为终止数字
def help(ans, start_i, end_i, start_j, end_j, cur_num, n):
    # 如果不存在遍历区间，则不会进入下面四个for循环中的任意一个
    # 会持续进行递归，导致编译栈溢出
    # 这种情况就是当n为某个奇数的平方且c = m = sqrt(n)的时候会出现
    # 譬如填充5*5的矩阵且n = 25，最中间那个数字会出现的情况
    # 额外判断这种条件，将最中间的数字填充上并退出递归即可
    if start_i == end_i and start_j == end_j:
        ans[start_i][start_j] = cur_num
        return
    # 未填充矩阵的上边界：从左往右，固定start_i，正序遍历j
    for j in range(start_j, end_j):
        ans[start_i][j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的右边界：从上往下，固定end_j，正序遍历i
    for i in range(start_i, end_i):
        ans[i][end_j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的下边界：从右往左，固定end_i，逆序遍历j
    for j in range(end_j, start_j, -1):
        ans[end_i][j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 未填充矩阵的左边界：从下往上，固定start_j，逆序遍历j
    for i in range(end_i, start_i, -1):
        ans[i][start_j] = str(cur_num)
        cur_num += 1
        if cur_num > n: return
    # 对未填充数组进行递归
    # start_i, end_i, start_j, end_j需要修改
    help(ans, start_i+1, end_i-1, start_j+1, end_j-1, cur_num, n)

# 输入数字n，行数m
n, m = map(int, input().split())
# 计算列数c，为n除以m后向上取整
c = ceil(n / m)

# 初始化答案螺旋数组，先用"*"填充
ans = [["*"] * c for _ in range(m)]

# 递归入口：start_i, end_i, start_j, end_j
# 分别传入0, m-1, 0, c-1
help(ans, 0, m-1, 0, c-1, 1, n)
# 逐行输出螺旋矩阵
for row in ans:
    print(*row)

Java

import java.util.Scanner;

public class Main {
    // 递归函数
    // ans为答案螺旋矩阵
    // start_i, end_i, start_j, end_j分别为子矩阵的起始、终止的i和j下标
    // cur_num为未填充子矩阵左上角的第一个数
    // n为终止数字
    static void help(String[][] ans, int start_i, int end_i, int start_j, int end_j, int cur_num, int n) {
        // 如果不存在遍历区间，则不会进入下面四个for循环中的任意一个
        // 会持续进行递归，导致编译栈溢出
        // 这种情况就是当n为某个奇数的平方且c = m = sqrt(n)的时候会出现
        // 譬如填充5*5的矩阵且n = 25，最中间那个数字会出现的情况
        // 额外判断这种条件，将最中间的数字填充上并退出递归即可
        if (start_i == end_i && start_j == end_j) {
            ans[start_i][start_j] = String.valueOf(cur_num);
            return;
        }
        // 未填充矩阵的上边界：从左往右，固定start_i，正序遍历j
        for (int j = start_j; j <= end_j; j++) {
            ans[start_i][j] = String.valueOf(cur_num++);
            if (cur_num > n) return;
        }
        // 未填充矩阵的右边界：从上往下，固定end_j，正序遍历i
        for (int i = start_i + 1; i <= end_i; i++) {
            ans[i][end_j] = String.valueOf(cur_num++);
            if (cur_num > n) return;
        }
        // 未填充矩阵的下边界：从右往左，固定end_i，逆序遍历j
        for (int j = end_j - 1; j >= start_j; j--) {
            ans[end_i][j] = String.valueOf(cur_num++);
            if (cur_num > n) return;
        }
        // 未填充矩阵的左边界：从下往上，固定start_j，逆序遍历i
        for (int i = end_i - 1; i > start_i; i--) {
            ans[i][start_j] = String.valueOf(cur_num++);
            if (cur_num > n) return;
        }
        // 对未填充数组进行递归
        // start_i, end_i, start_j, end_j需要修改
        help(ans, start_i + 1, end_i - 1, start_j + 1, end_j - 1, cur_num, n);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 输入数字n，行数m
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        // 计算列数c，n除以m后向上取整
        int c = (int) Math.ceil((double) n / m);

        // 初始化答案螺旋数组，先用"*"填充
        String[][] ans = new String[m][c];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < c; j++) {
                ans[i][j] = "*";
            }
        }

        // 递归入口：start_i, end_i, start_j, end_j
        // 分别传入0, m-1, 0, c-1
        help(ans, 0, m - 1, 0, c - 1, 1, n);
        // 逐行输出螺旋矩阵
        for (String[] row : ans) {
            System.out.println(String.join(" ", row));
        }
    }
}

C++

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

// 递归函数
// ans为答案螺旋矩阵
// start_i, end_i, start_j, end_j分别为子矩阵的起始、终止的i和j下标
// cur_num为未填充子矩阵左上角的第一个数
// n为终止数字
void help(vector<vector<string>>& ans, int start_i, int end_i, int start_j, int end_j, int& cur_num, int n) {
    // 如果不存在遍历区间，则不会进入下面四个for循环中的任意一个
    // 会持续进行递归，导致编译栈溢出
    // 这种情况就是当n为某个奇数的平方且c = m = sqrt(n)的时候会出现
    // 譬如填充5*5的矩阵且n = 25，最中间那个数字会出现的情况
    // 额外判断这种条件，将最中间的数字填充上并退出递归即可
    if (start_i == end_i && start_j == end_j) {
        ans[start_i][start_j] = to_string(cur_num);
        return;
    }
    // 未填充矩阵的上边界：从左往右，固定start_i，正序遍历j
    for (int j = start_j; j <= end_j; j++) {
        ans[start_i][j] = to_string(cur_num++);
        if (cur_num > n) return;
    }
    // 未填充矩阵的右边界：从上往下，固定end_j，正序遍历i
    for (int i = start_i + 1; i <= end_i; i++) {
        ans[i][end_j] = to_string(cur_num++);
        if (cur_num > n) return;
    }
    // 未填充矩阵的下边界：从右往左，固定end_i，逆序遍历j
    for (int j = end_j - 1; j >= start_j; j--) {
        ans[end_i][j] = to_string(cur_num++);
        if (cur_num > n) return;
    }
    // 未填充矩阵的左边界：从下往上，固定start_j，逆序遍历i
    for (int i = end_i - 1; i > start_i; i--) {
        ans[i][start_j] = to_string(cur_num++);
        if (cur_num > n) return;
    }
    // 对未填充数组进行递归
    // start_i, end_i, start_j, end_j需要修改
    help(ans, start_i + 1, end_i - 1, start_j + 1, end_j - 1, cur_num, n);
}

int main() {
    // 输入数字n，行数m
    int n, m;
    cin >> n >> m;
    // 计算列数c，n除以m后向上取整
    int c = ceil(static_cast<double>(n) / m);

    // 初始化答案螺旋数组，先用"*"填充
    vector<vector<string>> ans(m, vector<string>(c, "*"));

    int cur_num = 1;
    // 递归入口：start_i, end_i, start_j, end_j
    // 分别传入0, m-1, 0, c-1
    help(ans, 0, m - 1, 0, c - 1, cur_num, n);
    // 逐行输出螺旋矩阵
    for (const auto& row : ans) {
        for (const auto& elem : row) {
            cout << elem << " ";
        }
        cout << endl;
    }

    return 0;
}

C

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

// 递归函数
// ans为答案螺旋矩阵
// start_i, end_i, start_j, end_j分别为子矩阵的起始、终止的i和j下标
// cur_num为未填充子矩阵左上角的第一个数
// n为终止数字
void fillSpiral(int **ans, int start_i, int end_i, int start_j, int end_j, int *cur_num, int n) {
    // 如果不存在遍历区间，则不会进入下面四个for循环中的任意一个
    // 会持续进行递归，导致编译栈溢出
    // 这种情况就是当n为某个奇数的平方且c = m = sqrt(n)的时候会出现
    // 譬如填充5*5的矩阵且n = 25，最中间那个数字会出现的情况
    // 额外判断这种条件，将最中间的数字填充上并退出递归即可
    if (start_i == end_i && start_j == end_j) {
        ans[start_i][start_j] = *cur_num;
        return;
    }
    // 未填充矩阵的上边界：从左往右，固定start_i，正序遍历j
    for (int j = start_j; j < end_j; j++) {
        ans[start_i][j] = (*cur_num)++;
        if (*cur_num > n) return;
    }
    // 未填充矩阵的右边界：从上往下，固定end_j，正序遍历i
    for (int i = start_i; i < end_i; i++) {
        ans[i][end_j] = (*cur_num)++;
        if (*cur_num > n) return;
    }
    // 未填充矩阵的下边界：从右往左，固定end_i，逆序遍历j
    for (int j = end_j; j > start_j; j--) {
        ans[end_i][j] = (*cur_num)++;
        if (*cur_num > n) return;
    }
    // 未填充矩阵的左边界：从下往上，固定start_j，逆序遍历i
    for (int i = end_i; i > start_i; i--) {
        ans[i][start_j] = (*cur_num)++;
        if (*cur_num > n) return;
    }
    // 对未填充数组进行递归
    // start_i, end_i, start_j, end_j需要修改
    fillSpiral(ans, start_i + 1, end_i - 1, start_j + 1, end_j - 1, cur_num, n);
}

int main() {
    int n, m;
    // 输入数字n，行数m
    scanf("%d %d", &n, &m);
    // 计算列数c，n除以m后向上取整
    int c = (int)ceil((double)n / m);

    // 初始化答案螺旋数组，先用0填充
    int **ans = (int **)malloc(m * sizeof(int *));
    for (int i = 0; i < m; i++) {
        ans[i] = (int *)malloc(c * sizeof(int));
        for (int j = 0; j < c; j++) {
            ans[i][j] = 0;
        }
    }

    int cur_num = 1;
    // 递归入口：start_i, end_i, start_j, end_j
    // 分别传入0, m-1, 0, c-1
    fillSpiral(ans, 0, m - 1, 0, c - 1, &cur_num, n);

    // 逐行输出螺旋矩阵
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < c; j++) {
            if (ans[i][j] == 0) {
                printf("*");
            } else {
                printf("%d", ans[i][j]);
            }
            if (j < c - 1) {
                printf(" ");
            }
        }
        printf("\n");
    }

    // 释放内存
    for (int i = 0; i < m; i++) {
        free(ans[i]);
    }
    free(ans);

    return 0;
}

Node JavaScript

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

rl.question('', (input) => {
    const [n, m] = input.split(' ').map(Number);
    const c = Math.ceil(n / m);

    // 初始化答案螺旋数组，先用""填充
*    const ans = Array.from({ length: m }, () => Array(c).fill("*"));

    // 递归函数
    function help(start_i, end_i, start_j, end_j, cur_num) {
        if (start_i === end_i && start_j === end_j) {
            ans[start_i][start_j] = cur_num.toString();
            return;
        }
        // 上边界
        for (let j = start_j; j < end_j; j++) {
            ans[start_i][j] = cur_num.toString();
            cur_num++;
            if (cur_num > n) return;
        }
        // 右边界
        for (let i = start_i; i < end_i; i++) {
            ans[i][end_j] = cur_num.toString();
            cur_num++;
            if (cur_num > n) return;
        }
        // 下边界
        for (let j = end_j; j > start_j; j--) {
            ans[end_i][j] = cur_num.toString();
            cur_num++;
            if (cur_num > n) return;
        }
        // 左边界
        for (let i = end_i; i > start_i; i--) {
            ans[i][start_j] = cur_num.toString();
            cur_num++;
            if (cur_num > n) return;
        }
        // 递归处理内部子矩阵
        help(start_i + 1, end_i - 1, start_j + 1, end_j - 1, cur_num);
    }

    // 初始化递归
    help(0, m - 1, 0, c - 1, 1);

    // 输出结果
    ans.forEach(row => console.log(row.join(' ')));
    rl.close();
});

Go

package main

import (
        "fmt"
        "math"
        "strconv"
)

// 递归函数
// ans为答案螺旋矩阵
// start_i, end_i, start_j, end_j分别为子矩阵的起始、终止的i和j下标
// curNum为未填充子矩阵左上角的第一个数
// n为终止数字
func fillSpiral(ans [][]string, startI, endI, startJ, endJ, curNum, n int) {
        // 如果不存在遍历区间，则不会进入下面四个for循环中的任意一个
        // 会持续进行递归，导致编译栈溢出
        // 这种情况就是当n为某个奇数的平方且c = m = sqrt(n)的时候会出现
        // 譬如填充5*5的矩阵且n = 25，最中间那个数字会出现的情况
        // 额外判断这种条件，将最中间的数字填充上并退出递归即可
        if startI == endI && startJ == endJ {
                ans[startI][startJ] = strconv.Itoa(curNum)
                return
        }
        // 未填充矩阵的上边界：从左往右，固定startI，正序遍历j
        for j := startJ; j < endJ; j++ {
                ans[startI][j] = strconv.Itoa(curNum)
                curNum++
                if curNum > n {
                        return
                }
        }
        // 未填充矩阵的右边界：从上往下，固定endJ，正序遍历i
        for i := startI; i < endI; i++ {
                ans[i][endJ] = strconv.Itoa(curNum)
                curNum++
                if curNum > n {
                        return
                }
        }
        // 未填充矩阵的下边界：从右往左，固定endI，逆序遍历j
        for j := endJ; j > startJ; j-- {
                ans[endI][j] = strconv.Itoa(curNum)
                curNum++
                if curNum > n {
                        return
                }
        }
        // 未填充矩阵的左边界：从下往上，固定startJ，逆序遍历i
        for i := endI; i > startI; i-- {
                ans[i][startJ] = strconv.Itoa(curNum)
                curNum++
                if curNum > n {
                        return
                }
        }
        // 对未填充数组进行递归
        // startI, endI, startJ, endJ需要修改
        fillSpiral(ans, startI+1, endI-1, startJ+1, endJ-1, curNum, n)
}

func main() {
        // 输入数字n，行数m
        var n, m int
        fmt.Scan(&n, &m)
        // 计算列数c，n除以m后向上取整
        c := int(math.Ceil(float64(n) / float64(m)))

        // 初始化答案螺旋数组，先用"*"填充
        ans := make([][]string, m)
        for i := range ans {
                ans[i] = make([]string, c)
                for j := range ans[i] {
                        ans[i][j] = "*"
                }
        }

        // 递归入口：startI, endI, startJ, endJ
        // 分别传入0, m-1, 0, c-1
        curNum := 1
        fillSpiral(ans, 0, m-1, 0, c-1, curNum, n)

        // 逐行输出螺旋矩阵
        for _, row := range ans {
                for j, elem := range row {
                        if j > 0 {
                                fmt.Print(" ")
                        }
                        fmt.Print(elem)
                }
                fmt.Println()
        }
}

时空复杂度

时间复杂度：O(N)。需要填充N个数字。

空间复杂度：O(MC)。忽略递归所需要的编译栈空间，需要构建大小为c*m的二维矩阵ans。

华为OD算法/大厂面试高频题算法练习冲刺训练

  • 华子OD算法/大厂面试高频题算法冲刺训练目前开始常态化报名！目前已服务1000+同学成功上岸！

  • 课程讲师为全网200w+粉丝编程博主@吴师兄学算法 以及小红书头部编程博主@闭着眼睛学数理化

  • 90+天陪伴式学习，100+直播课时，300+动画图解视频，500+LeetCode经典题，500+华为OD真题/大厂真题，还有简历修改、模拟面试、陪伴小群、资深HR对接将为你解锁

  • 可上全网独家的欧弟OJ系统练习华子OD、大厂真题

  • 可查看链接OD真题汇总(持续更新)

  • 绿色聊天软件戳 od1441或了解更多

【华为OD笔试套题双机位A卷正在更新】双机位A卷+2025C+B+2024E+D卷机考套题汇总【真实反馈，不断更新，限时免费】
weixin_48157259的博客
04-22 2万+
可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
华为OD机试双机位A卷 - 螺旋数字矩阵 (Python & C/C++ & JAVA & JS & GO)
qq_45776114的博客
09-29 246
华为OD机试2025双机位A卷 螺旋数字矩阵，提供Java、C++、Python、Go、JavaScript源码实现，并提供完整思路讲解
华为OD机考双机位A卷 - 流浪地球（Java & Python& JS & C/C++ & GO ）
算法大师！
09-16 2284
华为OD机考双机位A卷 - 流浪地球（OD上机考试双机位A卷）。提供在线OJ刷题。Java、C++、Python、GO语言、C语言、JavaScript题解，并提供完整思路讲解。
【双机位A卷】华为OD笔试之【模拟】双机位A-比赛的冠亚季军【Py/Java/C++/C/JS/Go六种语言】【欧弟算法】全网注释最详细分类最全的华子OD真题题解
weixin_48157259的博客
09-23 37
可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【双机位A卷】华为OD笔试之【模拟】双机位A-猜数字【Py/Java/C++/C/JS/Go六种语言OD独家双机位A卷真题】【欧弟算法】全网注释最详细分类最全的华子OD真题题解
weixin_48157259的博客
09-24 37
可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【双机位A卷】华为OD笔试之【贪心】双机位A-租车骑绿岛【Py/Java/C++/C/JS/Go六种语言OD独家双机位A卷真题】【欧弟算法】全网注释最详细分类最全的华子OD真题题解
weixin_48157259的博客
09-20 927
可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
牛客算法_哈希
qinwenjng120的博客
10-08 283
思路：1. map, key存放数组元素，value存放下标位置2. 如果key重复，记录最小的下标3. 遍历map, target-当前map位置的值， 判断差x在map中的位置3.1 当前map位置的值 = x, 找到下一个=x的位置3.2 当前map位置的值!= x, 直接从map中定位到下标遍历顺序与插入顺序一致。
(done) 并行计算 CS149 Lecture8 (并行原语 Data-Parallel Thinking)
shimly123456的博客
10-08 432
TODO: here。
CCF-GESP 等级考试 2025年9月认证C++三级真题解析
最新发布
hz_zhangrl的博客
10-10 735
摘要：CCF-GESP等级考试2025年9月认证C++三级真题解析。每题不仅给出答案，还给出详细解析。对编程题，每题给出编程思路和按思路编写的参考程序。
PTA6-2 使用函数求Fibonacci数（C）
qq_44966403的博客
10-07 799
本题要求实现求Fabonacci数列项的函数。所谓Fibonacci数列就是满足任一项数字是前两项的和（最开始两项均定义为1）的数列。函数fib应返回第n项Fibonacci数。题目保证输入输出在长整型范围内。/* 你的代码将被嵌在这里 */
二叉树进阶面试题：最小栈 栈的压入·弹出序列 二叉树层序遍历
asciiletters的博客
10-06 783
摘要： 本文通过三个算法题解析栈与队列的应用。首先设计最小栈，通过双栈（主栈+辅助栈）实现O(1)获取最小值；其次验证栈的压入弹出序列，模拟入栈出栈过程匹配给定序列；最后实现二叉树层序遍历，利用队列分层记录节点，通过levelsize控制每层数据量。代码均给出关键思路与实现，突出栈的"先进后出"与队列的"先进先出"特性在算法中的灵活运用。 关键词： 最小栈、辅助栈、层序遍历、队列、广度优先搜索
2025年9月GESP（C++六级）：货物运输
王老师青少年编程
10-09 456
2025年9月GESP（C++六级）：货物运输
关于OFDM-PNC系统信道估计算法
fengfuyao985的博客
10-10 683
参考代码 ofdm-pnc 系统信道估计算 www.youwenfan.com/contentcsi/64944.html。： 块状导频：每16个子载波插入1个导频（适用于慢衰落） 梳状导频：每4个子载波插入1个导频（适用于快衰落）： 并行FFT引擎（Xilinx FFT IP核） 流水线化矩阵运算。： 粗估计（LS算法） 精细化（MMSE迭代）
LeetCode 面试经典 150_哈希表_存在重复元素 II（46_219_C++_简单）
huayimenghan的博客
10-09 1024
LeetCode 面试经典 150_哈希表_存在重复元素 II（46_219_C++_简单） 题目描述： 给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。
RRT星算法的路径规划与修剪的实现
t19875128的博客
10-10 166
参考代码 rrt*算法的实现，可以实现路径的规划与修剪 www.youwenfan.com/contentcsi/65130.html。RRT*算法在复杂障碍物环境中可实现平均0.8秒的路径规划速度（1000x1000栅格地图），路径平滑度提升40%以上。RRT*（快速扩展随机树星算法）是一种基于采样的路径规划算法，通过。
算法20. 有效的括号
hahaha_1112的博客
10-06 154
摘要 该问题要求判断由括号组成的字符串是否有效。有效字符串需满足：左括号必须用同类型右括号闭合，且按正确顺序闭合。解决方法是使用栈数据结构：遇到左括号入栈，遇到右括号则检查是否与栈顶左括号匹配。关键点包括：字符串长度为偶数才能有效；使用哈希表存储括号对应关系；最终栈为空才返回真。该方法时间复杂度O(n)，空间复杂度O(n)，能高效验证括号有效性。
课题学习(二十四)---专栏终章：基于四元数和扩展卡尔曼滤波的姿态解算算法（MPU9250+STM32F103ZET6）
我的博客
10-04 764
一、基于四元数的扩展卡尔曼滤波算法声明：本人水平有限，博客可能存在部分错误的地方，请广大读者谅解并向本人反馈错误。由于研究生生涯已经结束了，未来接触惯性导航方向的机会可能不多了，因此我研究生课题的系列博客也就到此结束了，关于本专栏的最终章，我想把基于四元数和扩展卡尔曼滤波的姿态解算算法向大家介绍一下。如果有需要源程序代码，可以点击下面的链接下载我的资源或者一、基于四元数的扩展卡尔曼滤波算法1.1 扩展卡尔曼滤波算法算法的一些详细介绍在这就不展开了，这里只是简单介绍下算法的流程。
Levenberg-Marquardt（ LM）算法详解和二次曲线拟合实战
qq_36812406的博客
10-09 1198
min⁡x∑i1m∥rix∥2∥rx∥2xmin​i1∑m​∥ri​x∥2∥rx∥2x∈Rnx∈Rn：待优化的参数向量rixri​x：第iii个残差rxrx：残差向量（长度为mmm功能实现情况残差计算√雅可比手动推导√动态调整阻尼因子 λ√更新接受/拒绝判断√停止条件控制√收敛稳定，适合大多数非线性问题可动态在牛顿法与梯度下降法之间切换在初始值较好时表现优异。
洛谷 - dp 题目详解 2（超详细版）
xzk20121002的博客
10-05 844
本文介绍了两个动态规划问题：P1002"过河卒"和P1616"疯狂的采药"。第一个问题使用标数法计算卒在棋盘上避开马控制点的路径条数，通过二维DP数组求解。第二个问题则是一维完全背包问题，通过优化空间的一维DP数组计算在规定时间内可采草药的最大价值。两题均采用动态规划思想，分别涉及棋盘路径计数和背包问题两种典型应用场景。文章提供了完整的思路分析和C++代码实现。
华为od机试双机位吗
12-03
华为OD机是华为公司开发的一种云计算产品，用于支持企业的研发和创新工作。而双机位是指在一个设备上同时安装和运行两个操作系统，以实现双重备份和冗余。根据我的了解，华为OD机试不支持双机位。 华为OD机试是建立在华为云平台上的创新应用研发环境，其主要功能是提供研发云虚拟机、容灾备份、测试环境等服务。在华为OD机试中，用户可以使用自己的账号登录到云虚拟机上进行各种开发、测试等工作，而不需要自己购买和维护硬件设备。 双机位的概念主要应用于一些对高可用性和冗余性要求较高的场景，比如金融交易系统、电信基站等。通过在一个设备上同时安装两个操作系统，可以在一台设备出现故障时，快速切换到另一台设备，从而实现系统的高可用性和稳定性。 然而，根据我的了解，华为OD机试并不支持双机位技术。因为华为OD机试的主要目的是为企业提供一个方便、高效、可扩展的研发和测试环境，而不是提供高可用性和冗余性的解决方案。因此，在使用华为OD机试时，用户可以选择使用备份和容灾功能来确保数据的安全性，但不能实现双机位的冗余备份。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

闭着眼睛学算法

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

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

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

打赏作者

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

抵扣说明：

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

余额充值