矩阵链乘法

Description

Matrix multiplication problem is a typical example of dynamical programming.

Suppose you have to evaluate an expression like A*B*C*D*E where A,B,C,D and E are matrices. Since matrix multiplication is associative, the order in which multiplications are performed is arbitrary. However, the number of elementary multiplications needed strongly depends on the evaluation order you choose.
For example, let A be a 50*10 matrix, B a 10*20 matrix and C a 20*5 matrix.
There are two different strategies to compute A*B*C, namely (A*B)*C and A*(B*C).
The first one takes 15000 elementary multiplications, but the second one only 3500.

Your job is to write a program that determines the number of elementary multiplications needed for a given evaluation strategy.

Input Specification

Input consists of two parts: a list of matrices and a list of expressions. 
The first line of the input file contains one integer  n (1 <=  n <= 26), representing the number of matrices in the first part. The next  n lines each contain one capital letter, specifying the name of the matrix, and two integers, specifying the number of rows and columns of the matrix. 
The second part of the input file strictly adheres to the following syntax (given in EBNF):

SecondPart = Line { Line } <EOF>
Line       = Expression <CR>
Expression = Matrix | "(" Expression Expression ")"
Matrix     = "A" | "B" | "C" | ... | "X" | "Y" | "Z"

Output Specification

For each expression found in the second part of the input file, print one line containing the word "error" if evaluation of the expression leads to an error due to non-matching matrices. Otherwise print one line containing the number of elementary multiplications needed to evaluate the expression in the way specified by the parentheses.

Sample Input

9
A 50 10
B 10 20
C 20 5
D 30 35
E 35 15
F 15 5
G 5 10
H 10 20
I 20 25
A
B
C
(AA)
(AB)
(AC)
(A(BC))
((AB)C)
(((((DE)F)G)H)I)
(D(E(F(G(HI)))))
((D(EF))((GH)I))

Sample Output

0
0
0
error
10000
error
3500
15000
40500
47500
15125

中文描述：
  
  

   
   
矩阵乘法问题是动态规划的一个典型例子。
   
   
假设你必须评估像A * B * C的表达* D * E其中A，B，C，D和E是矩阵。由于矩阵乘法是缔合，其中乘法的执行顺序是任意的。然而，强烈要求基本的乘法的数量取决于您选择的评估顺序。
例如，设A是一个50×10矩阵，B 10 * 20矩阵和C 20 * 5矩阵。
有两种不同的策略来计算A * B * C，即（A * B）* C和A *（B * C）。
第一个就是15000次基本乘法，但第二个只有3500。
   
   
你的任务是写一个程序，确定需要对给定的评估策略基本乘法的数目。
   
   
输入规格
输入由两个部分组成：矩阵列表和表达式的列表。 
输入文件的第一行包含一个整数
   
   Ñ（1 <= 
   
   Ñ <= 26），表示的矩阵中的第一部分的数目。接下来
   
   ñ行包含1个大写字母，以指定矩阵的名称，和两个整数，以指定矩阵的行数和列数。 
输入文件的第二部分严格遵守以下语法（在EBNF给出）：
   
   

   
   
二部=行{线} <EOF> 
行=表达<CR> 
表达=矩阵| “（”表达式表达式“）” 
矩阵= “A” | “B” | “C” | ... | “X” | “Y” | “Z”

   
   

   
   
输出规格
在输入文件的第二部分中找到的每个表达式，打印包含单词“错误”，如果表达式的评估导致的误差由于不匹配的矩阵的一行。否则打印包含以评估由括号中指定的方式表达所需的基本的乘法次数一行。
  
  
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<iostream>
using namespace std;
typedef struct Matrix
{
	int row;
	int col;
	char c;
	Matrix()
	{
		row=0;
		col=0;
		c='\0';
	}
}Matrix,*MatrixLink;
Matrix Mats[26];//the matrix lib
Matrix stack_ex[1000];//the expression stack
int top=-1;
int n=0;//the number of the matrix
char query_str[1000]={'\0'};
/*for test*/
int test()
{
	return(0);
}
/*calculate the matrix*/
bool CalcMa(Matrix &m1,Matrix &m2,Matrix &m3)
{
	if(m1.col!=m2.row)
	{
		return(false);
	}
	else
	{
		m3.row=m1.row;
		m3.col=m2.col;
		return(true);
	}
}
/*calculate the matrix multiplications */
int CalcQue(char que[])
{
	int num=0;
	top=-1;
	int i=0;
	while(que[i]!='\0')
	{
		Matrix NewMa;
		switch(que[i])
		{
		case '('://push the stack
			top++;
			stack_ex[top].c='(';
			break;
		case ')'://pop the stack until the first '('(include it),and calculate the AB matrix multiplication,and tne new matrix updated.
			if(CalcMa(stack_ex[top-1],stack_ex[top],NewMa))
			{
				num+=stack_ex[top-1].row*stack_ex[top-1].col*stack_ex[top].col;
				top-=2;
				stack_ex[top].row=NewMa.row;
				stack_ex[top].col=NewMa.col;
				//printf("%s %d\n",que,num);
			}
			else
			{
				num=-1;
				return(num);
			}
			break;
		default://push the stack
			top++;
			stack_ex[top].c=que[i];
			stack_ex[top].row=Mats[que[i]-65].row;
			stack_ex[top].col=Mats[que[i]-65].col;
			break;
		}
		i++;
	}
	return(num);
}
/*main process*/
int MainProc()
{
	//initialize
	scanf("%d",&n);
	int i=0,row=0,col=0;
	char c='\0';//the name of the matrix
	for(i=0;i<=n-1;i++)
	{
		scanf("%s%d%d",query_str,&row,&col);
		c=query_str[0];
		//save to the matrix lib
		Mats[c-65].row=row;
		Mats[c-65].col=col;
		Mats[c-65].c=c;
	}
	//deal with the query
	while(scanf("%s",query_str)!=EOF)
	{
		if(query_str[0]=='\0')
		{
			continue;
		}
		int ele_num=CalcQue(query_str);
		if(ele_num>=0)
		{
			printf("%d\n",ele_num);
		}
		else
		{
			printf("error\n");
		}
	}
	return(0);
}
int main()
{
	MainProc();
	return(0);
}