华为机试 矩阵乘法的估量

代码如下：

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

int main()
{
    int n;
    
    while(cin>>n)
    {
        vector<vector<int>> mats(n,vector<int>(2));
        vector<int> que; //记录将要操作的矩阵下标
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<2;j++)
            {
                cin>>mats[i][j];
            }
        }
        string str;
        cin>>str;
        stack<char> s1;  //栈操作
        long long sum=0; 
        vector<vector<int>> ans(1,vector<int>(2)); //矩阵相乘中间结果
        
        for(int i=0;i<str.length();i++)
        {
            int len =0; //每次循环操作符个数需重置为0；
            if(str.at(i) !='(')
            {
                s1.push(str.at(i));
            }
            else
            {
                while(s1.top()!='(') //判断操作符是否到（ 若没到，则len++ 若len>=2,说明括号包含两个以上矩阵，先计算
                {
                    len++; //操作符个数
                    char c = s1.top();
                    int index = c-65; //ASCII码，获取当前矩阵下标
                    if(index>=0) //此题必定大于0
                    {
                        que.push_back(c-65); //放入当前坐标
                        
                        if(len ==2) 
                        {
                            if(ans[0][0]==0)//中间结果还没有 计算第一次相乘
                            {
                                 sum += mats[que.at(1)][0]*mats[que.at(1)][1]*mats[que.at(0)][1];
                                 ans[0][0] = mats[que.at(1)][0]; //将矩阵中第一个的行数赋值给新矩阵的行数
                                 ans[0][1] = mats[que.at(0)][1]; //将矩阵中第二个的列数赋值给新矩阵的列数 （栈操作，先进后出，所以AB =BC 即 pxn,m*p格式）
                                 que.pop_back(); 
                                 que.pop_back();//操作符已用 出栈
                            }
                            else
                            {
                                vector<int> mat; //如果已经有中间结果了，那么先计算（）中的矩阵 再和中间结果相乘
                                if(mats[que.at(0)][0] == mats[que.at(1)][1]) //这里输入必定是正确的，可以不判断
                                {
                                    sum+= mats[que.at(0)][0]*mats[que.at(1)][0]*mats[que.at(0)][1];
                                    mat.push_back(mats[que.at(1)][0]);
                                    mat.push_back(mats[que.at(0)][1]);
                                    
                                    if(ans[0][1] == mat[0]) //计算此时两矩阵结果与原中间结果
                                    {
                                        sum+= ans[0][0]*ans[0][1]*mat[1];
                                        ans[0][1] = mat[1];  //更新中间结果
                                    }
                                }
                               
                                que.pop_back();
                                que.pop_back();
                            }
                        }
                    }
                    
                    s1.pop(); //出栈 此时出栈的是操作符
                    
                }
                if(!que.empty() && ans[0][0]!=0) //如果que不为空，即表示此时仍有运算符需要计算  ans[0][0] 必定不为0.可以删除
                {
                   if(mats[que.at(0)][1] == ans[0][0]) //判断是m*p p*n 还是p*n m*p 此时表达的是 m*p p*n 即更新新矩阵行数即可
                    {
                        sum+=ans[0][0]*ans[0][1]*mats[que.at(0)][0];
                        ans[0][0] = mats[que.at(0)][0];
                    }
                    else //更新新矩阵列数
                    {
                        sum+=ans[0][0]*ans[0][1]*mats[que.at(0)][1];
                        ans[0][1] = mats[que.at(0)][1];
                    }
                    que.clear(); //清空栈 由于此题不会出现（ABC）（ABCD） 即que.size()最多为1；
                }
                s1.pop(); //出栈，此时出栈的是  "(", 即碰见 ")" 将操作符出完栈 还需要匹配一个"(";
            }
            
        }
        cout<<sum<<endl;
    }
    
    return 0;
}