矩阵连乘思路

https://blog.csdn.net/qq_32919451/article/details/80643118?utm_medium=distribute.pc_relevant.none-task-blog-2_defaultbaidujs_title~default-1.no_search_link&spm=1001.2101.3001.4242

【问题描述】

给定n个矩阵｛A1,A2,…,An｝，其中Ai与Ai+1是可乘的，i=1，2…，n-1。如何确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。例如，给定三个连乘矩阵{A1，A2，A3}的维数分别是10100，1005和550，采用（A1A2）A3，乘法次数为101005+10550=7500次，而采用A1（A2A3），乘法次数为100550+10100*50=75000次乘法，显然，最好的次序是（A1A2)A3，乘法次数为7500次。

分析：

矩阵链乘法问题描述：
给定由n个矩阵构成的序列｛A1，A2，…，An}，对乘积A1A2…An，找到最小化乘法次数的加括号方法。

1）寻找最优子结构

此问题最难的地方在于找到最优子结构。对乘积A1A2…An的任意加括号方法都会将序列在某个地方分成两部分，也就是最后一次乘法计算的地方，我们将这个位置记为k，也就是说首先计算A1...Ak和Ak+1...An，然后再将这两部分的结果相乘。
最优子结构如下：假设A1A2…An的一个最优加括号把乘积在Ak和Ak+1间分开，则前缀子链A1…Ak的加括号方式必定为A1…An的一个最优加括号，后缀子链同理。

开始并不知道k的确切位置，需要遍历所有位置以保证找到合适的k来分割乘积。

2）构造递归解

• m[i][j] 表示A[i:j]的计算量 ；
• A[i:k]的计算量为m[i][k];
• A[k+1 : j]的计算量为m[k+1][j]

因此，m[i][j] = m[i][k] + m[k+1][j] + p[i-1] * p[i] * p[j];

因为i、j是矩阵的下标所以是大于0的,比如矩阵是A1-A6 i=1,j=6
其中p是每个矩阵的行数和列数如下图

（p[i-1] * p[i] * p[j]：最后两个矩阵的计算量）
此时i=1，j=6
假设 此时k的位置（括号的位置）在p3,所以计算量就是min（m[1][3]+m[4][6]+p[0]p[3]p[6]）

计算顺序

矩阵A1-A6,可以看出k的范围在p1-p5间
i=1，j=6，n=6，所以k的范围i<=k<j-1

#include<iostream>
using namespace std;
 
const int N=7;
//p为矩阵链，p[0],p[1]代表第一个矩阵的行数和列数，p[1],p[2]代表第二个矩阵的行数和列数......length为p的长度
//所以如果有六个矩阵，length=7，m为存储最优结果的二维矩阵，s为存储选择最优结果路线的
//二维矩阵
void MatrixChainOrder(int *p,int m[N][N],int s[N][N],int length)
{
    int n=length-1;
    int l,i,j,k,q=0;
    //m[i][i]只有一个矩阵，所以相乘次数为0，即m[i][i]=0;
    for(i=1;i<length;i++)
    {
        m[i][i]=0;
    }
    //l表示矩阵链的长度
    // l=2时，计算 m[i,i+1],i=1,2,...,n-1 (长度l=2的链的最小代价)
    //    就算m[i,i+l-1]代价（比如长度4，是A2-A5 所以j=i+l-1） 所以i+（l-1）<=n
    for(l=2;l<=n;l++)
    {
        for(i=1;i<=n-l+1;i++)
        {
            j=i+l-1; //以i为起始位置，j为长度为l的链的末位，
            m[i][j]=0x7fffffff;
            //16进制的max，初始化，如果这个值没有被覆盖掉说明肯定最终结果就没有走它
            //k从i到j-1,以k为位置划分,在本题k的范围是p1-p5
            for(k=i;k<=j-1;k++)
            {
                q=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
                if(q<m[i][j])//如果比这个值小，则覆盖
                {
                    m[i][j]=q;
                    s[i][j]=k;//保存k的位置
                }
            }
        }
    }
    cout << m[1][N-1] << endl;//最优的结果放在最后一个数组中
}
void PrintAnswer(int s[N][N],int i,int j)
{
    if(i==j)
    {
        cout<<"A"<<i;
    }
    else
    {
        cout<<"(";
        PrintAnswer(s,i,s[i][j]);//矩阵A1-Ak  
        PrintAnswer(s,s[i][j]+1,j);//矩阵Ak+1-Aj 
        cout<<")";
    }
}
int main()
{
    int p[N]={30,35,15,5,10,20,25};
    int m[N][N],s[N][N];
    MatrixChainOrder(p,m,s,N);
    PrintAnswer(s,1,N-1);
    return 0;
}