矩阵乘法计算量估算

最新推荐文章于 2024-11-27 17:48:44 发布

原创最新推荐文章于 2024-11-27 17:48:44 发布 · 1k 阅读

1 ·

CC 4.0 BY-SA版权

华为机试同时被 2 个专栏收录

112 篇文章

订阅专栏

数组链表

26 篇文章

订阅专栏

本文介绍了一种通过优化矩阵乘法顺序来减少计算量的方法，并提供了一个使用栈实现的算法示例，该算法能根据不同的矩阵乘法规则计算所需的最少乘法次数。

题目描述：

矩阵乘法的运算量与矩阵乘法的顺序强相关。

例如：

A是一个50×10的矩阵，B是10×20的矩阵，C是20×5的矩阵

计算A*B*C有两种顺序：（（AB）C）或者（A（BC）），前者需要计算15000次乘法，后者只需要3500次。

编写程序计算不同的计算顺序需要进行的乘法次数

输入描述:

输入多行，先输入要计算乘法的矩阵个数n，每个矩阵的行数，列数，总共2n的数，最后输入要计算的法则

输出描述:

输出需要进行的乘法次数

思路：

用栈存储矩阵的行和列，若矩阵表达式为(A(BC(D(EF))))，首先将表达式化成(A(X(D(Y))))，然后通过找")"依次计算。

import java.util.Scanner;
import java.util.Stack;

public class Main
{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext())
        {
            int n = scanner.nextInt();
            int[][] matrix = new int[n][2];
            for (int i = 0; i < n; i++)
            {
                matrix[i][0] = scanner.nextInt();
                matrix[i][1] = scanner.nextInt();
            }
            String str = scanner.next();
            Stack<Integer> stack = new Stack<>();
            int res = 0;
            int index = 0;
            boolean flag = false;
            for (int i = 0; i < str.length(); i++)
            {
                char c = str.charAt(i);
                if (Character.isLetter(c)) //为矩阵
                {
                    if (!stack.isEmpty() && stack.peek() != -1) //栈顶不为"("时，计算矩阵并合并
                    {
                        int col = stack.pop();
                        int row = stack.pop();
                        int col2 = matrix[index][1];
                        res += col * row * col2;

                        stack.push(row);
                        stack.push(col2);
                    }
                    else
                    {
                        stack.push(matrix[index][0]);
                        stack.push(matrix[index][1]);
                    }
                    index++;
                }
                else if (c == '(')
                {
                    stack.push(-1);
                }
                else if (c == ')')
                {
                    int col = stack.pop();
                    int row = stack.pop();
                    stack.pop();  //弹出栈顶的"("
                    if (stack.size() <= 1)
                    {
                        System.out.println(res);
                        flag = true;
                        break;
                    }
                    if (stack.peek() != -1)  //若栈顶不为"("，弹出栈顶矩阵并计算
                    {
                        stack.pop();  //col2
                        int row2 = stack.pop();
                        res += row2 * row * col;
                        row = row2;
                    }
                    stack.push(row);
                    stack.push(col);
                }
            }
            if (flag == false)
                System.out.println(res);
        }

    }
}