精华内容
下载资源
问答
  • n个矩阵连乘的问题

    2021-04-25 20:33:52
    给定n个矩阵{A1,A2,……,An},其中Ai与Ai+1是可乘的,i=1,2,……,n-1。 例如: 计算三个矩阵连乘{A1,A2,A3};维数分别为10100 , 1005 , 5*50 按此顺序计算需要的次数((A1*A2)*A3):10X100X5+10X5X50=7500次 按...

    n个矩阵连乘的问题

    给定n个矩阵{A1,A2,……,An},其中Ai与Ai+1是可乘的,i=1,2,……,n-1。

    例如:

    计算三个矩阵连乘{A1,A2,A3};维数分别为10100 , 1005 , 5*50

    按此顺序计算需要的次数((A1*A2)*A3):10X100X5+10X5X50=7500次

    按此顺序计算需要的次数(A1*(A2*A3)):10X5X50+10X100X50=75000次

    所以要解决的问题是:如何确定矩阵连乘积A1A2,……An的计算次序,使得按此计算次序计算矩阵连乘积需要的数乘次数达到最小化。

    问题分析与描述:

    两个矩阵r1r2和r2r3的矩阵相乘需r1r2r3次乘法,那么n个矩阵相乘就得到很多种不同的计算方法其中乘法最少的所花费的时间肯定最少。

    那什么方法才能最快呢?

    我们先了解加括号:
    我们在每一个矩阵外面加一个括号,这样结果是不变的。但是当在两个矩阵外加一个括号运算方法被改变了((A1A2)A3)这两个(A1(A2A3))就是这样
    然后最广到n的情况怎么不同的括号结果也就不一样了最后我们求取最快的结果即可

    现在我们把这个矩阵这道题改变成加括号如何加括号才能使得最后的结果是最快的

    算法设计与思路

    我们将这个相乘的问题改变为加括号后我们来分析:
    以6个矩阵为例:
    在这里插入图片描述

    这是四个矩阵和他们的维数我们先自顶向上想求取最后结果:
    M1-4可以(A1)M1-3 or (A1A2)(A3A4)或者M1-3*A4
    这三种情况然后M值按以下的这颗树这样向下分
    我们将这个画成一棵树即为
    在这里插入图片描述
    最终我们在二叉树左右节点的位置求出最后小值就可得到最后答案M1-4

    这里我们可以发现是需要计算很多重复值如何减少这些浪费的时间呢?

    我们可以创建一个二维数组记录每一个保存的数据
    用i表示行j表示列的话 Mi-j表示i到j中最小的计算次数。
    当i=j时为0我们可以创建以下的二维数组m
    在这里插入图片描述

    最终的答案即为m[1][4]
    我们在表示每次插入的括号如
    在这里插入图片描述

    再次建立一个二维数组com起始为0
    则我们看到com【0】【2】=1我们就认为在第一个元素后加入括号A1M23
    com【0】【3】=3我们在第三个矩阵后加入括号M13
    A44;

    伪代码:

    course(int i,j)
    {int u,k,t;
    if(m[i][j]>=0
    return m[i][j];
    if(i==j) return 0;
    if(i=j-1){
    com[i][j+1]=i;
    m[i][j]=r[i]*r[i+1]*r[i+2];
    return m[i][j];}
    u=course(i,i)+course(i+1,j)+r[i*r[k+1*r[j+1];
    com[i][j]=i;
    for(k=i+1 ;k<j;k=k+1){
    t=course(i,i)+course(i+1,j)+r[i*r[k+1*r[j+1];
    if(t<u){
    u=t;
    com[i][j]=k;
    }
    }
    m[i][j]=u;
    return u;
    }
    
    

    c程序

    #include<stdio.h>
    int m[6][6];
    int com[6][6];
    int r[7]={30,35,15,5,10,20,25};
    int course(int i,int j){
    	printf("i=%dj=%d\n",i,j);
    	int u,s;
    	if(m[i][j]>=0){
    		return m[i][j];
    	}
    	if(i==j){
    		m[i][j]=0;
    		return 0;
    	}
    	if(i==j-1){
    		m[i][j]=r[i]*r[i+1]*r[i+2];
    		com[i][j]=i+1;
    		return r[i]*r[i+1]*r[i+2];
    	}printf("i=%d\n",i);
    	u=course(i,i)+course(i+1,j)+r[i]*r[i+1]*r[j+1];
    	com[i][j]=i+1;
    	for(int k=i+1;k<j;k++){
    		s=course(i,k)+course(k+1,j)+r[i]*r[k+1]*r[j+1];
         printf("i=%dj=%dk=%d\t%d\n",i,j,k,s);
    	if(u>s){
    		u=s;
    		com[i][j]=k+1;
    	}
    	}
    	m[i][j]=u;
            return u;
    }
    int main(){
    	int n=6;
      for(int i=0;i<6;i++){
      	for(int j=0;j<6;j++){
      	 m[i][j]=-1;
      	 com[i][j]=0;
    	  }
      }
      printf("最后答案%d\n",course(0,n-1));
       	   for(int i=0;i<6;i++){printf("\n");
      	for(int j=0;j<6;j++){
      		printf("m[%d][%d]%d\t",i,j,m[i][j]);
    	}}
    	   	   for(int i=0;i<6;i++){printf("\n");
      	for(int j=0;j<6;j++){
      		printf("com[%d][%d]%d\t",i,j,com[i][j]);
    	}}
    }
    
    展开全文
  • 矩阵连乘问题

    2014-04-20 21:02:58
    给定n个矩阵A1,A2,…,An,其中,Ai与Aj+1是可乘的,i=1,2,…,n-l。 你的任务是要确定矩阵连乘的运算次序,使计算这n个矩阵的连乘积A1A2…An时总的元素乘法次数达到最少。
  • 问题 给定n个矩阵 { A1,A2,A3,…,An } ,其中Ai与Ai+1是可乘的。考察这n个矩阵连乘积A1A2A3…An。

    问题

    给定n个矩阵 { A1,A2,A3,…,An } ,其中Ai与Ai+1是可乘的。考察这n个矩阵连乘积A1A2A3…An

    思路

    两矩阵相乘代码

    #include<iostream>
    void matrixmultiply(int** a, int** b, int** c, int ra, int ca, int rb, int cb) {
    	//ra、ca、rb、cb分别表示矩阵A和B的行数和列数
    	if (ca != cb)
    		error("矩阵不可乘!");
    	for (int i = 0; i < ra; i++) {
    		for (int j = 0; j < cb; j++) {
    			int sum = a[i][0] * b[0][j];
    			for (int k = 1; k < ca; k++)
    				sum += a[i][k] * b[k][j];
    			c[i][j] = sum;
    		}
    	}
    
    }
    

    由三个循环可知,两矩阵相乘共需计算 p * q * r 此数乘
    为方便后续计算,令矩阵 Ai 的维度为 pi-1*pi

    1. 分析最优解的结构

    将矩阵连乘积A1A2A3…An简记为A[i:j],假设最优解在Ak和Ak+1之间断开,则总计算量为A[1:k]的计算量加上A[k+1,n]的计算量,再加上两者相乘的计算量。

    • eg.((A1A2)(A3A4)),需先分别计算A1A2、A3A4的计算量,还需加上两者相乘的计算量

    A[1:k]和A[k+1:n]的最优解也是同样的问题,是动态规划问题的体现。

    2.建立递归关系

    设 A[i:j] 的最少此数乘为m[i][j] ,则原问题的最优解为m[1][n]。
    当i==j时,单一矩阵,无需计算,m=0;
    当i<j时,m[i][j]=min{m[i][k]+m[k+1][j]+pi-1 *pk *pj },i<=k<j

    3.计算最优值

    void MartixChain(int* p, int n, int** m, int** s) {
    	//s记录最优断开位子
    	for (int i = 1; i <= n; i++)
    		m[i][i] = 0;
    	for (int r = 2; r <= n; r++) {	//r为计算最优解的矩阵个数,从2到n
    		for (int i = 1; i <= n - r + 1; i++) {
    			int j = i + r + 1;
    			m[i][j] = m[i + 1][j] + p[i - 1] * p[i] * p[j];
    			s[i][j] = i;//记录位置
    			for (int k = i + 1; k < j; k++) {
    				int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
    				if (t < m[i][j]) {
    					m[i][j] = t;
    					s[i][j] = k;
    				}
    			}
    
    		}
    	}
    }
    

    由于过程中许多子序列多次计算,因此用数组s记录子序列的最优解,并采取从下向上(长度r从2到n)的方式来减少重复计算

    3.构造最优解

    void Traceback(int i, int j, int** s) {
    	if (i == j)
    		return;
    	Traceback(i, s[i][j], s);
    	Traceback(s[i][j] + 1, j, s);
    	cout << "Multiply A " << i << "," << s[i][j];
    	cout << " and A " << (s[i][j] + 1) << "," << j << endl;
    }
    

    从记录最优解位子的s数组可知,A[1:n]最优的加括号的位置为(A[1:s[1][n]])(A[s[1][n]+1][n]),以此类推
    不断调用Traceback,计算出最有计算次序。

    展开全文
  • 给定n个矩阵{A1A2…An},其中Ai和Ai+1是可乘的,考察这n个矩阵的连乘积A1A2…An。由于矩阵的乘法满足结合律,故计算矩阵的连乘积有许多不同的计算次序,而不同的计算次序,所需要计算的连乘次数也是不同的,求解连乘...

    1、动态规划法

    问题简述:

    给定n个矩阵{A1A2…An},其中Ai和Ai+1是可乘的,考察这n个矩阵的连乘积A1A2…An。由于矩阵的乘法满足结合律,故计算矩阵的连乘积有许多不同的计算次序,而不同的计算次序,所需要计算的连乘次数也是不同的,求解连乘次数最少的矩阵连乘最优次序。

    举例说明矩阵结合方式对数乘次数的影响:
    矩阵连乘积A1A2A3,3个矩阵的维数分别为10x100,100x5和5x50,连乘时加括号的方式有:

          ((A1*A2)*A3)     数乘次数:10*100*5+10*5*50=7500
          (A1*(A2*A3))     数乘次数:100*5*50+10*100*50=75000
    
    • 以矩阵链ABCD为例
    • 按照矩阵链长度递增计算最优值
    • 矩阵链长度为1时,分别计算出矩阵链A、B、C、D的最优值
    • 矩阵链长度为2时,分别计算出矩阵链AB、BC、CD的最优值
    • 矩阵链长度为3时,分别计算出矩阵链ABC、BCD的最优值
    • 矩阵链长度为4时,计算出矩阵链ABCD的最优值

    解答:我们按照动态规划的几个步骤来分析:

    (1)找出最优解的性质,刻画其特征结构

    对于矩阵连乘问题,最优解就是找到一种计算顺序,使得计算次数最少。

    令m[i][j]表示第i个矩阵至第j个矩阵这段的最优解。

    将矩阵连乘积 简记为A[i:j] ,这里i<=j.假设这个最优解在第k处断开,i<=k<j,则A[i:j]是最优的,那么A[i,k]和A[k+1:j]也是相应矩阵连乘的最优解。可以用反证法证明之。 这就是最优子结构,也是用动态规划法解题的重要特征之一。

    (2)建立递归关系
    设计算A[i:j],1≤i≤j≤n,所需要的最少数乘次数m[i,j],则原问题的最优值为m[1,n] 。

    当i=j时,A[i,j]=Ai, m[i,j]=0;(表示只有一个矩阵,如A1,没有和其他矩阵相乘,故乘的次数为0)
    
    当i<j时,m[i,j]=min{m[i,k]+m[k+1,j] +pi-1*pk*pj} ,其中 i<=k<j
    

    (相当于对i~j这段,把它分成2段,看哪种分法乘的次数最少,如A1,A2,A3,A4,则有3种分法:{A1}{A2A3A4 }、{A1A2}{A3A4 }、{A1A2A3}{A4 },其中{}表示其内部是最优解,如{A1A2A3}表示是A1A2A3的最优解),

    也即:
    在这里插入图片描述
    (3)计算最优值

    对于1≤i≤j≤n不同的有序对(i,j) 对于不同的子问题,因此不同子问题的个数最多只有o(n*n).但是若采用递归求解的话,许多子问题将被重复求解,所以子问题被重复求解,这也是适合用动态规划法解题的主要特征之一。

    用动态规划算法解此问题,可依据其递归式以自底向上的方式进行计算。在计算过程中,保存已解决的子问题答案。每个子问题只计算一次,而在后面需要时只要简单查一下,从而避免大量的重复计算,最终得到多项式时间的算法。

    对于 p={30 35 155 10 20 25}:
    在这里插入图片描述
    计算顺序为:
    在这里插入图片描述对上例,共6个矩阵(A1~A6),n=6,当r=3时,r循环里面的是3个矩阵的最优解,i从1->4,即求的是

    (A1A2A3),(A2A3A4),(A3A4A5),(A4A5A6)这4个矩阵段(长度为3)的最优解.当i=2时(A2A3A4)的最优解为{A2(A3A4) ,(A2A3)A4}的较小值。

    同理比如

    当R=2时,迭代计算出:
    
     m[1:2]=m[1:1]+m[2:2}+p[0]*p[1]*p[2];
    
     m[2:3]=m[2:2]+m[3:3]+p[1]*p[2]*p[3];
    
     m[3:4]=m[3:3]+m[4][4]+p[2]*p[3]*p[4];
    
     m[4:5]=m[4:4]+m[5][5]+p[3]*p[4]*p[5];
    
     m[5:6]=m[5][5]+m[6][6]+p[4]*p[5]*p[6];
    
     当R=3时,迭代计算出:
    
     m[1:3]=min(m[1:1]+m[2:3]+p[0]*p[1]*p[3],m[1:2]+m[3:3]+p[0]*p[2]*p[3]);
    
     m[2:4]=min(m[2:2]+m[3:4]+p[1]*p[2]*p[4],m[2:3]+m[4:4]+p[1]*p[3]*p[4]);
    
     ......
    
     m[4:6]=min(m[4:4]+m[5:6]+p[3]*p[4]*p[6],m[4:5]+m[6:6]+p[3]*p[5]*p[6]);
    
     ......
    

    下面代码中后面的k也相当于是从i到j-1递增的,只是单独把第一个(k=i)提了出来.

    下面给出动态规划求解最优值的代码:

    void MatrixChain(int *p,int n,int **m,int **s)
    
    {    //m是最优值,s是最优值的断开点的索引,n为题目所给的矩阵的个数(下面例子中)
    
    //矩阵段长度为1,则m[][]中对角线的值为0,表示只有一个矩阵,没有相乘的.
    
    for(int i = 1;i<=n;i++) m[i][i] = 0;           //本题中n=6             
    
    for(int r = 2;r<=n;r++){//对角线循环,r表示矩阵的长度(2,3…逐渐变长)  
    
       for(int i = 1;i<=n-r+1;i++){  //行循环
    
    //从第i个矩阵Ai开始,长度为r,则矩阵段为(Ai~Aj)
    
    int j = r+i-1;//列的控制,当前矩阵段(Ai~Aj)的起始为Ai,尾为Aj
    
    //求(Ai~Aj)中最小的,其实k应该从i开始,但先记录第一个值,k从i+1开始,这样也可以。
    
    //例如对(A2~A4),则i=2,j=4,下面一行的m[2][4]=m[3][4]+p[1]*p[2]*p[4],即A2(A3A4)
    
         m[i][j] = m[i+1][j] + p[i-1]*p[i]*p[j];
    
         s[i][j] = i;//记录断开点的索引
    
    //循环求出(Ai~Aj)中的最小数乘次数
    
         for(int k = i+1 ; k<j;k++){
    
    //将矩阵段(Ai~Aj)分成左右2部分(左m[i][k],右m[k+1][j]),
    //再加上左右2部分最后相乘的次数(p[i-1] *p[k]*p[j])
    
           int t = m[i][k] + m[k+1][j] + p[i-1] *p[k]*p[j];                  
    
           if(t<m[i][j])
    
           {  m[i][j] = t;  
              s[i][j] = k;  //保存最小的,即最优的结果
    
    }//if
    
         }//k
    
        }//i
    
    }//r
    
    }//MatrixChain
    
    • 矩阵连乘计算次序问题的最优解包含着其子问题的最优解。这种性质称为最优子结构性质。
    • 在分析问题的最优子结构性质时,所用的方法具有普遍性:首先假设由问题的最优解导出的子问题的解不是最优的,然后再设法说明在这个假设下可构造出比原问题最优解更好的解,从而导致矛盾。
    • 利用问题的最优子结构性质,以自底向上的方式递归地从子问题的最优解逐步构造出整个问题的最优解。最优子结构是问题能用动态规划算法求解的前提。
    • 递归算法求解问题时,每次产生的子问题并不总是新问题,有些子问题被反复计算多次。这种性质称为子问题的重叠性质。
    • 动态规划算法,对每一个子问题只解一次,而后将其解保存在一个表格中,当再次需要解此子问题时,只是简单地用常数时间查看一下结果。
    • 通常不同的子问题个数随问题的大小呈多项式增长。因此用动态规划算法只需要多项式时间,从而获得较高的解题效率。

    2、枚举法

    ABCD四个矩阵连乘
    在这里插入图片描述
    1、(A(BCD))——>(A(B(CD))),(A((BC)D));
    2、((AB)(CD))——>NULL;
    3、((ABC)D)——>((A(BC)D)),(((AB)C)D);

    对于上面四个矩阵来说,枚举方法是:
    1、括号加在A和B之间,矩阵链被分为(A)和(BCD);
    2、括号加在B和C之间,矩阵链被分为(AB)和(CD);
    3、括号加在C和D之间,矩阵链被分为(ABC)和(D);
    在第一步中分出的(A)已经不能在加括号了,所以结束;
    而(BCD)继续按照上面的步奏把括号依次加在B和C、C和D之间,其他情况相同。
    加括号的过程是递归的。

    程序实现

    //m数组内存放矩阵链的行列信息
    //m[i-1]和m[i]分别为第i个矩阵的行和列(i = 1、2、3...)
    int Best_Enum(int m[], int left, int right)
    {
    	//只有一个矩阵时,返回计算次数0
    	if (left == right)
    	{
    		return 0;
    	}
     
    	int min = INF; //无穷大
    	int i;
    	//括号依次加在第1、2、3...n-1个矩阵后面
    	for (i = left; i < right; i++)
    	{
    		//计算出这种完全加括号方式的计算次数
    		int count = Best_Enum(m, left, i) + Best_Enum(m, i+1, right);
    		count += m[left-1] * m[i] * m[right];
    		//选出最小的
    		if (count < min)
    		{
    			min = count;
    		}
    	}
    	return min;
    }
    

    3、备忘录法优化

    备忘录方法是动态规划算法的变形,与动态规划算法一样,备忘录算法用表格保存已解决的子问题的答案,在下次需要解此问题时只是简单地查看该问题的答案,而不必重新计算。与动态规划算法不同的是,备忘录算法的递归方式是自顶向下的,而动态规划算法是自底向上的。
    备忘录方法为每个子问题建立一个记录项,初始化时,该记录项存入一个特殊的值,表示该子问题尚未求解,对每个待求的子问题,首先查看其记录项。若记录项是原始值,则代表该问题是第一次遇到,计算该问题的值并保存;若记录项中存储的不是初始化时的特殊值,则表示子问题已经被计算过,此时只要从记录项中取出该子问题的解答即可,不必重新计算。
    在这里插入图片描述

    上图为递归枚举过程,小方块内的1:4代表第1个矩阵至第4个矩阵的完全加括号方式

    可以看到黄色方块中有很多重复计算,所以利用备忘录来保存计算结果,在每次进行计算前,
    先查表,看是否计算过,避免重复计算。

    程序实现

    #include <iostream>
    #include <cstdio>
    #include <cstring>
     
    using namespace std;
     
    #define SIZE 100
    #define INF 999999999
     
    int memo[SIZE][SIZE];
     
    //m数组内存放矩阵链的行列信息
    //m[i-1]和m[i]分别为第i个矩阵的行和列(i = 1、2、3...)
    int Best_Memo(int m[], int left, int right)
    {
    	//只有一个矩阵时,返回计算次数0
    	if (left == right)
    	{
    		return 0;
    	}
     
    	int min = INF;
    	int i;
    	//括号依次加在第1、2、3...n-1个矩阵后面
    	for (i = left; i < right; i++)
    	{
    		//计算出这种完全加括号方式的计算次数
    		int count;
    		if (memo[left][i] == 0)
    		{
    			memo[left][i] = Best_Memo(m, left, i);
    		}
    		count = memo[left][i];
    		if (memo[i+1][right] == 0)
    		{
    			memo[i+1][right] = Best_Memo(m, i+1, right);
    		}
    		count += memo[i+1][right];
    		count += m[left-1] * m[i] * m[right];
    		//选出最小的
    		if (count < min)
    		{
    			min = count;
    		}
    	}
    	return min;
    }
     
    int main(void)
    {
    	int m[SIZE];
    	int n;
    	while (scanf("%d", &n) != EOF)
    	{
    		int i;
    		for (i = 0; i < n; i++)
    		{
    			scanf("%d", &m[i]);
    		}
    		memset(memo, 0, sizeof(memo));
    		printf("%d\n", Best_Memo(m, 1, n-1));
    	}
    	return 0;
    }
    

    参考自:
    陈斌彬的技术博客
    庞老板

    展开全文
  • 给定n个矩阵{A1,A2,…,An}。其中Ai与Ai+1是可乘的,i=1,2,…,n-1。要求计算出这n个矩阵的连乘积A1A2…An最少需要多少次乘法。
    1、问题描述: 在科学计算中经常要计算矩阵的乘积。矩阵A和B可乘的条件是矩阵A的列数等于矩阵B的行数。若A是一个p×q的矩阵,B是一个q×r的矩阵,则其乘积C=AB是一个p×r的矩阵。 计算C=AB总共需要p×q×r次乘法。 现在的问题是,给定n个矩阵{A1,A2,…,An}。其中Ai与Ai+1是可乘的,i=1,2,…,n-1。 要求计算出这n个矩阵的连乘积A1A2…An最少需要多少次乘法。

    2、输入
    输入数据的第一行是一个整数n(0 < n <= 10),表示矩阵的个数。
    接下来的n行每行两个整数p,q( 0 < p,q < 100),分别表示一个矩阵的行数和列数。
     
    3、输出
    输出一个整数:计算连乘积最少需要乘法的次数。
     
    4、输入样例
    10 
    1 2 
    2 3 
    3 4 
    4 5 
    5 6 
    6 7 
    7 8 
    8 9 
    9 10 
    10 11
     
    5、输出样例
    438

    #include<iostream>
    #include<vector>
    #include<climits>
    using namespace std;
    
    int main() {
    
    	int N;//输入矩阵的数目
    	int i = 0, j = 0;
    	cin >> N;
    	vector<int>row(N);//各个矩阵的行
    	vector<int>col(N);//各个矩阵的列
    	int pos = 0;//记录从i到j乘法数目最少的括号的位置。
    	vector<vector<int>> dp(N, vector<int>(N));//这个就是备忘录,dp[i][j]代表从i到j的最少乘法数
    
    	int tmp = 0;//临时变量,用来赋值
    	for (tmp = 0; tmp < N; ++tmp) {
    		cin >> row[tmp] >> col[tmp];
    		dp[tmp][tmp] = 0;//单个矩阵没有乘法
    	}
    	for (i = N - 2; i >= 0; --i) {
    		for (j = i + 1; j < N; ++j) {
    			dp[i][j] = INT_MAX;
    			for (pos = i; pos < j; ++pos) {
    				tmp = dp[i][pos] + dp[pos + 1][j] + row[i] * col[pos] * col[j];
    				if (tmp < dp[i][j])
    					dp[i][j] = tmp;
    			}//end for pos
    		}//end for j
    	}//end for i
    	cout << "the minimum number is : " << dp[0][N - 1] << endl;
    }

    展开全文
  • 矩阵连乘

    2016-04-18 19:40:23
     给定n个矩阵{A1,A2,…,An},其中Ai与Ai+1是可乘的,i=1,2,…,n-1。要算出这n个矩阵的连乘积A1A2…An。由于矩阵乘法满足结合律,故计算矩阵的连乘积可以有许多不同的计算次序。这种计算次序可以用加括号的方式来...
  • 给定n个矩阵{A1A2…An},其中Ai和Ai+1是可乘的,考察这n个矩阵的连乘积A1A2…An。由于矩阵的乘法满足结合律,故计算矩阵的连乘积有许多不同的计算次序,而不同的计算次序,所需要计算的连乘次数也是不同的,求解连乘...
  • 矩阵连乘算法模板

    2017-03-20 22:28:11
    *给定n个矩阵{A1,A2,A3,...,An},求这n个矩阵的连乘积A1A2...An,乘法次数最小值和矩阵连乘最优计算次序。 *由于矩阵乘法满足结合律,故计算矩阵的连乘积可以有许多不同的计算次序。 *矩阵Ai的维度为 pi-1 X pi ...
  • 给定n个矩阵(A1,A2....An),其中Ai与Ai+1是可乘的,i=1,2,...,n-1.考察这n个矩阵的连乘积A1A2,...,An。 该资料为使用动态规划法解矩阵连乘积的最有计算次序问题,使用C++语言实现
  • 计算矩阵连乘积

    2019-10-16 12:26:24
    在科学计算中经常要计算矩阵的乘积。矩阵A和B可乘的条件是矩阵A的列数...现在的问题是,给定n个矩阵{A1,A2,…,An}。其中Ai与Ai+1是可乘的,i=1,2,…,n-1。要求计算出这n个矩阵的连乘积A1A2…An,最少的乘法次数。 ...
  • 给定n个矩阵{A1A2…An},其中Ai和Ai+1是可乘的,考察这n个矩阵的连乘积A1A2…An。由于矩阵的乘法满足结合律,故计算矩阵的连乘积有许多不同的计算次序,而不同的计算次序,所需要计算的连乘次数也是不同的,求解连乘...
  • 动态规划算法——矩阵连乘问题

    千次阅读 2015-10-11 01:37:51
    问题描述:给定n个矩阵{A1A2…An},其中Ai和Ai+1是可乘的,考察这n个矩阵的连乘积A1A2…An。由于矩阵的乘法满足结合律,故计算矩阵的连乘积有许多不同的计算次序,而不同的计算次序,所需要计算的连乘次数也是不同的...
  • 算法设计矩阵连乘

    2012-10-07 10:56:43
    给定n个矩阵A1,A2,…,An,其中,Ai与Aj+1是可乘的,i=1,2,…,n-1。 你的任务是要确定矩阵连乘的运算次序,使计算这n个矩阵的连乘积A1A2…An时总的元素乘法次数达到最少。 例如:3个矩阵A1,A2,A3,阶分别为...
  • 动态规划之矩阵连乘

    2019-05-16 12:42:31
    本博客转载自 ... 动态规划之矩阵连乘 以下内容参考(摘抄)...给定n个矩阵{A1,A2,…,An},其中Ai与Ai+1是可乘的,i=1,2,…,n-1。考察这n个矩阵的连乘积A1A2…An。由于矩阵乘法满足结合律,故计算矩阵的连乘积可...
  • 给定n个矩阵{A1,A2,……An},其中Ai与Ai+1是可乘的,i = 1,2,……,n-1。考察这n个矩阵的连乘积A1A2,……,An。加括号的位置不同,计算数乘次数不同。 计算最少数乘次数,并给出最优解。 得出递归式: m[i][j...
  • 矩阵链乘法

    2013-04-24 15:14:41
    给定n个矩阵{A1,A2,…,An},其中Ai与Ai+1是可乘的,i=1,2 ,…,n-1。如何确定计算矩阵连乘积的计算次序,使得依此次序计算矩阵连乘积需要的数乘次数最少。  Input 有N个矩阵连乘,用一行有n+1数数组表示,表示...
  • 动态规划算法之矩阵连乘问题思路

    万次阅读 多人点赞 2018-06-10 18:06:46
    本文转载自http://www.cnblogs.com/scarecrow-blog/p/3712580.html【问题描述】给定n个矩阵{A1,A2,…,An},其中Ai与Ai+1是可乘的,i=1,2…,n-1。如何确定计算矩阵连乘积的计算次序,使得依此次序计算矩阵连乘积...
  • 矩阵连乘的C++代码

    2013-02-12 12:05:35
    现在的问题是,给定n个矩阵{A1,A2,…,An}。其中Ai与Ai+1是可乘的,i=1,2,…,n-1。 要求计算出这n个矩阵的连乘积A1A2…An最少需要多少次乘法。 输入 输入数据的第一行是一整树n(0 < n ≤ 10),表示矩阵的个数...
  • 动态规划-矩阵链乘

    千次阅读 2012-11-11 10:27:23
    给定n个矩阵构成的一链给定{A1,A2,…,An},其中i=1,2,...,n.矩阵Ai的维数为pi-1*pi,如何确定计算矩阵连乘积的计算次序,使得依此次序计算矩阵连乘积需要的数乘次数最少。  最优子结构 对乘积A1A2...An的...
  • 矩阵链乘法问题:给定 n 个矩阵的链 <A1, A2, A3, ..., An>,矩阵 Ai 的规模为。求完全括号化方案,使得计算乘积A1A2...An所需要标量的乘法次数最少。 两个矩阵 A 和 B 只有相容,即 A 的列数等于 B 的行数...
  • 计算矩阵连乘积——动态规划

    千次阅读 2018-10-30 17:52:47
    在科学计算中经常要计算矩阵的乘积。矩阵A和B可乘的条件是矩阵A的列数等于...现在的问题是,给定n个矩阵{A1,A2,…,An}。其中Ai与Ai+1是可乘的,i=1,2,…,n-1。要求计算出这n个矩阵的连乘积A1A2…An,最少的乘法次...
  • 矩阵连乘--动态规划

    2016-04-17 21:02:19
    给定n个矩阵{A1,A2,…,An},其中Ai与Ai+1是可乘的,i=1,2,…,n-1。要算出这n个矩阵的连乘积A1A2…An。由于矩阵乘法满足结合律,故计算矩阵的连乘积可以有许多不同的计算次序。这种计算次序可以用加括号的方式来确定...
  • 给定n个矩阵{A1A2…An},其中Ai和Ai+1是可乘的,考察这n个矩阵的连乘积A1A2…An。由于矩阵的乘法满足结合律,故计算矩阵的连乘积有许多不同的计算次序,而不同的计算次序,所需要计算的连乘次数也是不同的,求解连乘...
  • FZU 1061 矩阵连乘

    2016-05-04 16:27:00
    Problem 1061 矩阵连乘 Accept: 445Submit: 1699 Time Limit: 1000 ...给定n个矩阵{A1,A2,...,An},考察这n个矩阵的连乘积A1A2...An。由于矩阵乘法满足结合律,故计算矩阵的连乘积可以有许多不同的计算次序,...
  • 给定n个矩阵{A1,A2,…,An},其中Ai与Ai+1是可乘的,i=1,2,…,n-1。要算出这n个矩阵的连乘积A1A2…An。由于矩阵乘法满足结合律,故计算矩阵的连乘积可以有许多不同的计算次序。这种计算次序可以用加括号的方式来确定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 969
精华内容 387
关键字:

给定n个矩阵a1a2