华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

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

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

一、题目描述

学校组织活动，将学生排成一个矩形方阵。请在矩形方阵中找到最大的位置相连的男生数量。

这个相连位置在一个直线上，方向可以是水平的，垂直的，成对角线的或者呈反对角线的.注:学生个数不会超过10000。

二、输入描述

输入的第一行为矩阵的行数和列数，接下来的n行为矩阵元素，元素间用","分隔。

三、输出描述

输出一个整数，表示矩阵中最长的位置相连的男生个数。

四、测试用例

测试用例1

1、输入

3,4
F,M,M,F
F,M,M,F
F,F,F,M

2、输出

3

测试用例2

1、输入

7,8
F,M,M,F,M,M,M,M
F,M,M,M,F,F,F,F
F,F,F,M,M,F,F,F
F,F,F,M,M,M,F,F
F,F,F,F,F,M,F,F
F,F,F,M,F,M,F,F
F,F,F,M,F,M,F,M

2、输出

5

五、解题思路

1、题目解析

本题的解题思路其实不难，遍历查找矩阵中每一个 M 点，然后求该 M 点的水平、垂直、正对角线、反对角线四个方向的 M 点个数，然后保留最大的个数

2、解体思路

1. 定义矩阵matrix，并初始化；
2. 定义矩阵中最长的位置相连的男生个数max；
3. 遍历矩阵，并跳过女生M；
4. 计算每行相连的男生个数；
5. 计算每列相连的男生个数；
6. 计算斜线相连的男生个数；
7. 计算反斜线相连的男生个数；
8. 相连最大值。

六、Python算法源码

def main():
    m, n = 0, 0  # 初始化行和列

    # 读取输入
    input_data = input().split(',')
    m = int(input_data[0])  # 矩阵的行数
    n = int(input_data[1])  # 矩阵的列数

    # 初始化矩阵
    matrix = []

    for i in range(m):
        line = input().split(',')  # 按逗号分隔每一行的输入
        matrix.append(line)  # 将每一行添加到矩阵中

    # 定义方向：{0,1}表示水平，{1,0}表示垂直，{1,1}表示斜向下，{1,-1}表示反斜线向下
    direction = [(0, 1), (1, 0), (1, 1), (1, -1)]

    # 记录矩阵中最长连续"M"的数量
    max_count = 0

    # 遍历整个矩阵
    for i in range(m):
        for j in range(n):
            if matrix[i][j] == "M":  # 如果当前元素是"M"
                for d in direction:
                    reverse_i = i - d[0]
                    reverse_j = j - d[1]

                    # 如果前一个位置包含'M'，说明这个"M"已经计算过，跳过
                    if 0 <= reverse_i < m and 0 <= reverse_j < n and matrix[reverse_i][reverse_j] == "M":
                        continue

                    next_i = i + d[0]
                    next_j = j + d[1]
                    same = 1  # 计数当前连续的"M"

                    # 计算每一行、每一列、斜线和反斜线中连续的"M"的数量
                    while 0 <= next_i < m and 0 <= next_j < n and matrix[next_i][next_j] == "M":
                        same += 1
                        next_i += d[0]
                        next_j += d[1]

                    # 更新最大连续"M"的数量
                    max_count = max(max_count, same)

    # 输出结果
    print(max_count)


if __name__ == "__main__":
    main()

七、JavaScript算法源码

function main() {
    let m = 0, n = 0;  // 初始化行和列

    // 读取输入
    const input = prompt("请输入行数和列数（以逗号分隔）:").split(",");
    m = parseInt(input[0]);  // 矩阵的行数
    n = parseInt(input[1]);  // 矩阵的列数

    // 初始化矩阵
    const matrix = [];

    for (let i = 0; i < m; i++) {
        const line = prompt(`请输入矩阵第${i + 1}行数据（以逗号分隔）:`).split(",");  // 按逗号分隔每一行的输入
        matrix.push(line);  // 将每一行添加到矩阵中
    }

    // 定义方向：{0,1}表示水平，{1,0}表示垂直，{1,1}表示斜向下，{1,-1}表示反斜线向下
    const direction = [[0, 1], [1, 0], [1, 1], [1, -1]];

    // 记录矩阵中最长连续"M"的数量
    let maxCount = 0;

    // 遍历整个矩阵
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            if (matrix[i][j] === "M") {  // 如果当前元素是"M"
                for (const d of direction) {
                    let reverseI = i - d[0];
                    let reverseJ = j - d[1];

                    // 如果前一个位置包含'M'，说明这个"M"已经计算过，跳过
                    if (reverseI >= 0 && reverseI < m && reverseJ >= 0 && reverseJ < n && matrix[reverseI][reverseJ] === "M") {
                        continue;
                    }

                    let nextI = i + d[0];
                    let nextJ = j + d[1];
                    let same = 1;  // 计数当前连续的"M"

                    // 计算每一行、每一列、斜线和反斜线中连续的"M"的数量
                    while (nextI >= 0 && nextI < m && nextJ >= 0 && nextJ < n && matrix[nextI][nextJ] === "M") {
                        same++;
                        nextI += d[0];
                        nextJ += d[1];
                    }

                    // 更新最大连续"M"的数量
                    maxCount = Math.max(maxCount, same);
                }
            }
        }
    }

    // 输出结果
    console.log(maxCount);
}

// 运行主函数
main();

八、C算法源码

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

// 定义矩阵的最大尺寸
#define MAX_SIZE 100

int main() {
    int m, n; // 矩阵的行数和列数
    char matrix[MAX_SIZE][MAX_SIZE]; // 矩阵

    // 读取输入行数和列数
    printf("请输入行数和列数（以逗号分隔）：");
    scanf("%d,%d", &m, &n);

    // 初始化矩阵
    for (int i = 0; i < m; i++) {
        printf("请输入矩阵第%d行数据（以逗号分隔）：", i + 1);
        for (int j = 0; j < n; j++) {
            scanf(" %c", &matrix[i][j]);
            if (j < n - 1) getchar();  // 读取逗号分隔符
        }
    }

    // 定义方向：{0,1}表示水平，{1,0}表示垂直，{1,1}表示斜向下，{1,-1}表示反斜线向下
    int direction[4][2] = {{0, 1}, {1, 0}, {1, 1}, {1, -1}};

    int maxCount = 0; // 记录矩阵中最长连续"M"的数量

    // 遍历整个矩阵
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == 'M') {  // 如果当前元素是"M"
                for (int d = 0; d < 4; d++) {
                    int reverseI = i - direction[d][0];
                    int reverseJ = j - direction[d][1];

                    // 如果前一个位置包含'M'，说明这个"M"已经计算过，跳过
                    if (reverseI >= 0 && reverseI < m && reverseJ >= 0 && reverseJ < n && matrix[reverseI][reverseJ] == 'M') {
                        continue;
                    }

                    int nextI = i + direction[d][0];
                    int nextJ = j + direction[d][1];
                    int same = 1;  // 计数当前连续的"M"

                    // 计算每一行、每一列、斜线和反斜线中连续的"M"的数量
                    while (nextI >= 0 && nextI < m && nextJ >= 0 && nextJ < n && matrix[nextI][nextJ] == 'M') {
                        same++;
                        nextI += direction[d][0];
                        nextJ += direction[d][1];
                    }

                    // 更新最大连续"M"的数量
                    if (same > maxCount) {
                        maxCount = same;
                    }
                }
            }
        }
    }

    // 输出结果
    printf("矩阵中最长连续的'M'的数量是: %d\n", maxCount);

    return 0;
}

九、C++算法源码

#include <iostream>
#include <vector>
#include <string>
#include <sstream>

using namespace std;

int main() {
    int m, n;  // 矩阵的行数和列数
    string input;

    // 读取输入行数和列数
    cout << "请输入行数和列数（以逗号分隔）：" << endl;
    getline(cin, input);
    stringstream ss(input);
    string temp;

    // 使用字符串流分割输入数据
    getline(ss, temp, ',');
    m = stoi(temp);
    getline(ss, temp, ',');
    n = stoi(temp);

    // 初始化矩阵
    vector<vector<string>> matrix(m, vector<string>(n));
    for (int i = 0; i < m; i++) {
        cout << "请输入矩阵第" << i + 1 << "行数据（以逗号分隔）：" << endl;
        getline(cin, input);
        stringstream ssRow(input);
        for (int j = 0; j < n; j++) {
            getline(ssRow, matrix[i][j], ',');  // 按逗号分隔每一行的输入
        }
    }

    // 定义方向：{0,1}表示水平，{1,0}表示垂直，{1,1}表示斜向下，{1,-1}表示反斜线向下
    vector<vector<int>> direction = {{0, 1}, {1, 0}, {1, 1}, {1, -1}};

    int maxCount = 0;  // 记录矩阵中最长连续"M"的数量

    // 遍历整个矩阵
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (matrix[i][j] == "M") {  // 如果当前元素是"M"
                for (auto &d : direction) {
                    int reverseI = i - d[0];
                    int reverseJ = j - d[1];

                    // 如果前一个位置包含'M'，说明这个"M"已经计算过，跳过
                    if (reverseI >= 0 && reverseI < m && reverseJ >= 0 && reverseJ < n && matrix[reverseI][reverseJ] == "M") {
                        continue;
                    }

                    int nextI = i + d[0];
                    int nextJ = j + d[1];
                    int same = 1;  // 计数当前连续的"M"

                    // 计算每一行、每一列、斜线和反斜线中连续的"M"的数量
                    while (nextI >= 0 && nextI < m && nextJ >= 0 && nextJ < n && matrix[nextI][nextJ] == "M") {
                        same++;
                        nextI += d[0];
                        nextJ += d[1];
                    }

                    // 更新最大连续"M"的数量
                    maxCount = max(maxCount, same);
                }
            }
        }
    }

    // 输出结果
    cout << "矩阵中最长连续的'M'的数量是: " << maxCount << endl;

    return 0;
}

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

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

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