矩阵乘法计算量估算

题目描述：

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

例如：

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);
        }

    }
}