校招算法笔面试 | 华为机试-矩阵乘法计算量估算

最新推荐文章于 2025-12-07 21:20:15 发布

原创最新推荐文章于 2025-12-07 21:20:15 发布 · 990 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #面试 #华为 #算法华为 #笔试 #算法华为笔试

题目## 题目

题目链接

解题思路

题目要求：
- 计算矩阵乘法的运算次数
- 根据给定的计算顺序(括号表达式)来确定运算顺序
- 矩阵个数n: $\leq n \leq 15$
- 矩阵行列数: $\leq row, col \leq 100$
关键点：
- 使用栈来存储待计算的矩阵信息
- 遇到右括号时，处理最近的两个矩阵相乘
- 计算量 = 第一个矩阵的行数 × 第一个矩阵的列数 × 第二个矩阵的列数

代码

while True:
    try:
        n = int(input())
        arr = []
        order = []
        res = 0
        # 读取矩阵维度信息
        for i in range(n):
            arr.append(list(map(int, input().split())))
        
        # 读取计算顺序
        f = input()
        for i in f:
            if i.isalpha():
                # 将字母转换为对应矩阵的维度信息
                order.append(arr[ord(i)-65])
            elif i == ')' and len(order) >= 2:
                # 遇到右括号，处理最近的两个矩阵
                b = order.pop()
                a = order.pop()
                # 计算乘法运算次数并累加
                res += a[0] * a[1] * b[1]
                # 将结果矩阵压入栈中
                order.append([a[0], b[1]])
        print(res)
    except:
        break

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int[][] arr = new int[n][2];
            List<int[]> order = new ArrayList<>();
            int res = 0;
            
            // 读取矩阵维度信息
            for (int i = 0; i < n; i++) {
                arr[i][0] = sc.nextInt();
                arr[i][1] = sc.nextInt();
            }
            
            // 读取计算顺序
            String f = sc.next();
            for (char c : f.toCharArray()) {
                if (Character.isLetter(c)) {
                    // 将字母转换为对应矩阵的维度信息
                    order.add(arr[c - 'A']);
                } else if (c == ')' && order.size() >= 2) {
                    // 遇到右括号，处理最近的两个矩阵
                    int[] b = order.remove(order.size() - 1);
                    int[] a = order.remove(order.size() - 1);
                    // 计算乘法运算次数并累加
                    res += a[0] * a[1] * b[1];
                    // 将结果矩阵压入栈中
                    order.add(new int[]{a[0], b[1]});
                }
            }
            System.out.println(res);
        }
    }
}

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

int main() {
    int n;
    while (cin >> n) {
        vector<vector<int>> arr(n, vector<int>(2));
        vector<vector<int>> order;
        int res = 0;
        
        // 读取矩阵维度信息
        for (int i = 0; i < n; i++) {
            cin >> arr[i][0] >> arr[i][1];
        }
        
        // 读取计算顺序
        string f;
        cin >> f;
        for (char c : f) {
            if (isalpha(c)) {
                // 将字母转换为对应矩阵的维度信息
                order.push_back(arr[c - 'A']);
            } else if (c == ')' && order.size() >= 2) {
                // 遇到右括号，处理最近的两个矩阵
                vector<int> b = order.back();
                order.pop_back();
                vector<int> a = order.back();
                order.pop_back();
                // 计算乘法运算次数并累加
                res += a[0] * a[1] * b[1];
                // 将结果矩阵压入栈中
                order.push_back({a[0], b[1]});
            }
        }
        cout << res << endl;
    }
    return 0;
}

算法分析

时间复杂度： $\mathcal{O}(n)$
- n为表达式长度
- 每个字符只需处理一次
空间复杂度： $\mathcal{O}(n)$
- 需要一个栈来存储矩阵信息

题目链接

解题思路

首先读取输入：
- 第一个矩阵的行数 $x$
- 第一个矩阵的列数和第二个矩阵的行数 $y$
- 第二个矩阵的列数 $z$
- 然后分别读取两个矩阵的元素
进行矩阵乘法计算：
- 结果矩阵的大小为 $\times z$
- 对于结果矩阵中的每个元素 $C [i] [j]$ ，计算公式为：
  $\sum_{k=0}^{y-1} A[i][k] \times B[k][j]$
输出结果矩阵

代码

while True:
    try:
        # 读取矩阵维度
        x = int(input())
        y = int(input())
        z = int(input())
        
        # 读取第一个矩阵
        matrix1 = []
        for _ in range(x):
            row = list(map(int, input().split()))
            matrix1.append(row)
            
        # 读取第二个矩阵
        matrix2 = []
        for _ in range(y):
            row = list(map(int, input().split()))
            matrix2.append(row)
            
        # 计算矩阵乘法
        result = [[0] * z for _ in range(x)]
        for i in range(x):
            for j in range(z):
                for k in range(y):
                    result[i][j] += matrix1[i][k] * matrix2[k][j]
        
        # 输出结果
        for row in result:
            print(' '.join(map(str, row)))
            
    except EOFError:
        break

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            // 读取矩阵维度
            int x = sc.nextInt();
            int y = sc.nextInt();
            int z = sc.nextInt();
            
            // 读取第一个矩阵
            int[][] matrix1 = new int[x][y];
            for (int i = 0; i < x; i++) {
                for (int j = 0; j < y; j++) {
                    matrix1[i][j] = sc.nextInt();
                }
            }
            
            // 读取第二个矩阵
            int[][] matrix2 = new int[y][z];
            for (int i = 0; i < y; i++) {
                for (int j = 0; j < z; j++) {
                    matrix2[i][j] = sc.nextInt();
                }
            }
            
            // 计算矩阵乘法
            int[][] result = new int[x][z];
            for (int i = 0; i < x; i++) {
                for (int j = 0; j < z; j++) {
                    for (int k = 0; k < y; k++) {
                        result[i][j] += matrix1[i][k] * matrix2[k][j];
                    }
                }
            }
            
            // 输出结果
            for (int i = 0; i < x; i++) {
                for (int j = 0; j < z; j++) {
                    System.out.print(result[i][j]);
                    if (j < z - 1) {
                        System.out.print(" ");
                    }
                }
                System.out.println();
            }
        }
    }
}

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

int main() {
    int x, y, z;
    while (cin >> x >> y >> z) {
        // 读取第一个矩阵
        vector<vector<int>> matrix1(x, vector<int>(y));
        for (int i = 0; i < x; i++) {
            for (int j = 0; j < y; j++) {
                cin >> matrix1[i][j];
            }
        }
        
        // 读取第二个矩阵
        vector<vector<int>> matrix2(y, vector<int>(z));
        for (int i = 0; i < y; i++) {
            for (int j = 0; j < z; j++) {
                cin >> matrix2[i][j];
            }
        }
        
        // 计算矩阵乘法
        vector<vector<int>> result(x, vector<int>(z, 0));
        for (int i = 0; i < x; i++) {
            for (int j = 0; j < z; j++) {
                for (int k = 0; k < y; k++) {
                    result[i][j] += matrix1[i][k] * matrix2[k][j];
                }
            }
        }
        
        // 输出结果
        for (int i = 0; i < x; i++) {
            for (int j = 0; j < z; j++) {
                cout << result[i][j];
                if (j < z - 1) cout << " ";
            }
            cout << endl;
        }
    }
    return 0;
}