动态规划矩阵连乘算法.docx
- 文档编号:12274996
- 上传时间:2023-04-17
- 格式:DOCX
- 页数:11
- 大小:19.50KB
动态规划矩阵连乘算法.docx
《动态规划矩阵连乘算法.docx》由会员分享,可在线阅读,更多相关《动态规划矩阵连乘算法.docx(11页珍藏版)》请在冰豆网上搜索。
动态规划矩阵连乘算法
问题描述:
给定n个矩阵:
A1,A2,...,An,其中Ai与Ai+1是可乘的,i=1,2...,n-1。
确定计算矩阵连乘积的计算次序,使得依此次序计算矩阵连乘积需要的数乘次数最少。
输入数据为矩阵个数和每个矩阵规模,输出结果为计算矩阵连乘积的计算次序和最少数乘次数。
?
?
?
问题解析:
由于矩阵乘法满足结合律,故计算矩阵的连乘积可以有许多不同的计算次序。
这种计算次序可以用加括号的方式来确定。
若一个矩阵连乘积的计算次序完全确定,也就是说该连乘积已完全加括号,则可以依此次序反复调用2个矩阵相乘的标准算法计算出矩阵连乘积。
?
?
?
?
完全加括号的矩阵连乘积可递归地定义为:
?
?
?
(1)单个矩阵是完全加括号的;
?
?
?
(2)矩阵连乘积A是完全加括号的,则A可表示为2个完全加括号的矩阵连乘积B和C的乘积并加括号,即A=(BC)
?
?
?
?
例如,矩阵连乘积A1A2A3A4有5种不同的完全加括号的方式:
(A1(A2(A3A4))),(A1((A2A3)A4)),((A1A2)(A3A4)),((A1(A2A3))A4),(((A1A2)A3)A4)。
每一种完全加括号的方式对应于一个矩阵连乘积的计算次序,这决定着作乘积所需要的计算量。
?
?
?
看下面一个例子,计算三个矩阵连乘{A1,A2,A3};维数分别为10*100,100*5,5*50按此顺序计算需要的次数((A1*A2)*A3):
10X100X5+10X5X50=7500次,按此顺序计算需要的次数(A1*(A2*A3)):
10*5*50+10*100*50=75000次
?
?
?
所以问题是:
如何确定运算顺序,可以使计算量达到最小化。
?
?
?
?
?
?
?
算法思路:
?
?
?
例:
设要计算矩阵连乘乘积A1A2A3A4A5A6,其中各矩阵的维数分别是:
?
?
?
A1:
30*35;?
?
A2:
35*15;?
?
A3:
15*5;?
?
A4:
5*10;?
?
A5:
10*20;?
?
A6:
20*25?
?
?
?
递推关系:
?
?
?
?
设计算A[i:
j],1≤i≤j≤n,所需要的最少数乘次数m[i,j],则原问题的最优值为m[1,n]。
?
?
?
当i=j时,A[i:
j]=Ai,因此,m[i][i]=0,i=1,2,…,n
当i j]的最优次序在Ak和Ak+1之间断开,i<=k m[i][j]=m[i][k]+m[k+1][j]+pi-1pkpj。 由于在计算是并不知道断开点k的位置,所以k还未定。 不过k的位置只有j-i个可能。 因此,k是这j-i个位置使计算量达到最小的那个位置。 综上,有递推关系如下: 构造最优解: 若将对应m[i][j]的断开位置k记为s[i][j],在计算出最优值m[i][j]后,可递归地由s[i][j]构造出相应的最优解。 s[i][j]中的数表明,计算矩阵链A[i: j]的最佳方式应在矩阵Ak和Ak+1之间断开,即最优的加括号方式应为(A[i: k])(A[k+1: j)。 因此,从s[1][n]记录的信息可知计算A[1: n]的最优加括号方式为(A[1: s[1][n]])(A[s[1][n]+1: n]),进一步递推,A[1: s[1][n]]的最优加括号方式为(A[1: s[1][s[1][n]]])(A[s[1][s[1][n]]+1: s[1][s[1][n]]])。 同理可以确定A[s[1][n]+1: n]的最优加括号方式在s[s[1][n]+1][n]处断开...照此递推下去,最终可以确定A[1: n]的最优完全加括号方式,及构造出问题的一个最优解。 1、穷举法 列举出所有可能的计算次序,并计算出每一种计算次序相应需要的数乘次数,从中找出一种数乘次数最少的计算次序。 对于n个矩阵的连乘积,设其不同的计算次序为P(n)。 每种加括号方式都可以分解为两个子矩阵的加括号问题: (A1...Ak)(Ak+1…An)可以得到关于P(n)的递推式如下: 以上递推关系说明,P(n)是随n的增长呈指数增长的。 因此,穷举法不是一个多项式时间复杂度算法。 2、重叠递归 从以上递推关系和构造最优解思路出发,即可写出有子问题重叠性的递归代码实现: //3d1-1重叠子问题的递归最优解 //A130*35A235*15A315*5A45*10A510*20A620*25 //p[0-6]={30,35,15,5,10,20,25} #include"stdafx.h" #include usingnamespacestd; constintL=7; intRecurMatrixChain(inti,intj,int**s,int*p);//递归求最优解 voidTraceback(inti,intj,int**s);//构造最优解 intmain() { intp[L]={30,35,15,5,10,20,25}; int**s=newint*[L]; for(inti=0;i { s[i]=newint[L]; } cout<<"矩阵的最少计算次数为: "< cout<<"矩阵最优计算次序为: "< Traceback(1,6,s); return0; } intRecurMatrixChain(inti,intj,int**s,int*p) { if(i==j)return0; intu=RecurMatrixChain(i,i,s,p)+RecurMatrixChain(i+1,j,s,p)+p[i-1]*p[i]*p[j]; s[i][j]=i; for(intk=i+1;k { intt=RecurMatrixChain(i,k,s,p)+RecurMatrixChain(k+1,j,s,p)+p[i-1]*p[k]*p[j]; if(t { u=t; s[i][j]=k; } } returnu; } voidTraceback(inti,intj,int**s) { if(i==j)return; Traceback(i,s[i][j],s); Traceback(s[i][j]+1,j,s); cout<<"MultiplyA"< cout<<"andA"<<(s[i][j]+1)<<","< } 1.用算法RecurMatrixChain(1,4,s,p)计算a[1: 4]的计算递归树如下图所示: 2. 从上图可以看出很多子问题被重复运算。 可以证明,该算法的计算时间T(n)有指数下界。 设算法中判断语句和赋值语句为常数时间,则由算法的递归部分可得关于T(n)的递归不等式: 3. 用数学归纳法可以证明 ,因此,算法RecurMatrixChain的计算时间也随n指数增长。 4. 3、备忘录递归算法 5. 备忘录方法用表格保存已解决的子问题答案,在下次需要解决此子问题时,只要简单查看该子问题的解答,而不必重新计算。 备忘录方法为每一个子问题建立一个记录项,初始化时,该记录项存入一个特殊的值,表示该子问题尚未求解。 在求解的过程中,对每个带求的子问题,首先查看其相应的记录项。 若记录项中存储的是初始化时存入的特殊值,则表示该问题是第一次遇到,此时计算出该子问题的解,并将其保存在相应的记录项中,以备以后查看。 若记录项中存储的已不是初始化时存入的特殊值,则表示该子问题已被计算过,相应的记录项中存储的是该子问题的解答。 此时从记录项中取出该子问题的解答即可,而不必重新计算。 //3d1-2矩阵连乘备忘录递归实现 //A130*35A235*15A315*5A45*10A510*20A620*25 //p[0-6]={30,35,15,5,10,20,25} #include"stdafx.h" #include usingnamespacestd; constintL=7; intLookupChain(inti,intj,int**m,int**s,int*p); intMemoizedMatrixChain(intn,int**m,int**s,int*p); voidTraceback(inti,intj,int**s);//构造最优解 intmain() { intp[L]={30,35,15,5,10,20,25}; int**s=newint*[L]; int**m=newint*[L]; for(inti=0;i { s[i]=newint[L]; m[i]=newint[L]; } cout<<"矩阵的最少计算次数为: "< cout<<"矩阵最优计算次序为: "< Traceback(1,6,s); return0; } intMemoizedMatrixChain(intn,int**m,int**s,int*p) { for(inti=1;i<=n;i++) { for(intj=1;j<=n;j++) { m[i][j]=0; } } returnLookupChain(1,n,m,s,p); } intLookupChain(inti,intj,int**m,int**s,int*p) { if(m[i][j]>0) { returnm[i][j]; } if(i==j) { return0; } intu=LookupChain(i,i,m,s,p)+LookupChain(i+1,j,m,s,p)+p[i-1]*p[i]*p[j]; s[i][j]=i; for(intk=i+1;k { intt=LookupChain(i,k,m,s,p)+LookupChain(k+1,j,m,s,p)+p[i-1]*p[k]*p[j]; if(t { u=t; s[i][j]=k; } } m[i][j]=u; returnu; } voidTraceback(inti,intj,int**s) { if(i==j)return; Traceback(i,s[i][j],s); Traceback(s[i][j]+1,j,s); cout<<"MultiplyA"< cout<<"andA"<<(s[i][j]+1)<<","< } 算法通过数组m记录子问题的最优值,m初始化为0,表明相应的子问题还没有被计算。 在调用LookupChain时,若m[i][j]>0,则表示其中存储的是所要求子问题的计算结果,直接返回即可。 否则与直接递归算法一样递归计算,并将计算结果存入m[i][j]中返回。 备忘录算法耗时O(n^3),将直接递归算法的计算时间从2^n降至O(n^3)。 3、动态规划迭代实现 用动态规划迭代方式解决此问题,可依据其递归式自底向上的方式进行计算。 在计算过程中,保存已解决的子问题的答案。 每个子问题只计算一次,而在后面需要时只需简单检查一下,从而避免了大量的重复计算,最终得到多项式时间的算法。 //3d1-2矩阵连乘动态规划迭代实现 //A130*35A235*15A315*5A45*10A510*20A620*25 //p[0-6]={30,35,15,5,10,20,25} #include"stdafx.h" #include usingnamespacestd; constintL=7; intMatrixChain(intn,int**m,int**s,int*p); voidTraceback(inti,intj,int**s);//构造最优解 intmain() { intp[L]={30,35,15,5,10,20,25}; int**s=newint*[L]; int**m=newint*[L]; for(inti=0;i { s[i]=newint[L]; m[i]=newint[L]; } cout<<"矩阵的最少计算次数为: "< cout<<"矩阵最优计算次序为: "< Traceback(1,6,s); return0; } intMatrixChain(intn,int**m,int**s,int*p) { for(inti=1;i<=n;i++) { m[i][i]=0; } for(intr=2;r<=n;r++)//r为当前计算的链长(子问题规模) { for(inti=1;i<=n-r+1;i++)//n-r+1为最后一个r链的前边界 { intj=i+r-1;//计算前边界为r,链长为r的链的后边界 m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j];//将链ij划分为A(i)*(A[i+1: j]) s[i][j]=i; for(intk=i+1;k { //将链ij划分为(A[i: k])*(A[k+1: j]) intt=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]; if(t { m[i][j]=t; s[i][j]=k; } } } } returnm[1][L-1]; } voidTraceback(inti,intj,int**s) { if(i==j)return; Traceback(i,s[i][j],s); Traceback(s[i][j]+1,j,s); cout<<"MultiplyA"< cout<<"andA"<<(s[i][j]+1)<<","< } 上述迭代算法的运行过程如下图所示: 如图所示: 当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]); ...... 依次类推,根据之前计算的m值,迭代计算最优解。 与备忘录方法相比,此方法会将每个子问题计算一遍,而备忘录方法则更灵活,当子问题中的部分子问题不必求解释,用备忘录方法较有利,因为从控制结构可以看出,该方法只解那些确实需要求解的子问题
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 动态 规划 矩阵 算法