解题（JuZhengCalculate-矩阵乘法计算量）

题目描述

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

例如：

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

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

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

输入描述:

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

输出描述:

输出需要进行的乘法次数

示例1

输入

3
50 10
10 20
20 5
(A(BC))

输出

3500

代码如下：

 package com.yzh.xuexi;

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

 public class JuZhengCalculate {

     public static void main(String[] args) {
         Scanner scanner=new Scanner(System.in);
         while(scanner.hasNext()){
             int n=Integer.parseInt(scanner.nextLine());
             int[][] arr=new int[n][];
             for(int i=0;i<arr.length;i++){
                 arr[i]=new int[2];
                 String[] sArr=scanner.nextLine().split("\\s+");
                 arr[i][0]=Integer.parseInt(sArr[0]);
                 arr[i][1]=Integer.parseInt(sArr[1]);
             }
             String rule=scanner.nextLine();
             System.out.println(juZhengCalculate(arr, rule));

         }
         scanner.close();
     }
     /*
      * 用栈（依次遍历）：遇到“(”直接跳过，什么也不做。遇到“字母”时就压栈，遇到“)”时就连续出两个字母（每个字母对应一个矩阵），做相应计算（累加每次乘法次数），这时会得到一个新矩阵，
      * 用一个不重复的字母对应新矩阵并压栈。处理完最后一个“)”得到计算结果（累加值）。
      */
     private static int juZhengCalculate(int[][] arr,String rule) {
         Stack<Character> stack=new Stack<Character>();
         char[] cArr=rule.toCharArray();
         char c1,c2;
         int number=0;
         int[] jzArr1,jzArr2;
         int[][] newArr=new int[26][];
         char newC='a';
         for (int i = 0; i <cArr.length; i++) {
             if (cArr[i]>=65&&cArr[i]<=90) {
                 stack.push(cArr[i]);
             }else if (cArr[i]==')') {
                 if (stack.size()==1) {
                     return number;
                 }
                 c2=stack.pop();
                 c1=stack.pop();
                 if (c1>=65&&c1<=90) {
                     jzArr1=arr[c1-65];
                 }else {
                     jzArr1=newArr[c1-97];
                 }

                 if (c2>=65&&c2<=90) {
                     jzArr2=arr[c2-65];
                 }else {
                     jzArr2=newArr[c2-97];
                 }
                 number+=jzArr1[0]*jzArr1[1]*jzArr2[1];
                 int[] tempArr={jzArr1[0],jzArr2[1]};
                 newArr[newC-97]=tempArr;
                 stack.push(newC++);
             }
         }
         return number;

     }
 }

3500