矩阵连乘

   问题描述：给定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次
      所以问题是：如何确定运算顺序，可以使计算量达到最小化。

动态规划方案：

#include <iostream>
#include<algorithm>
#include<stdio.h>
#include<string.h>
using namespace std;
const int N=100+1;
int m

,s

,p
,n;
void show(int i,int j)
{
if (i==j)
return;
show(i,s[i][j]);
show(s[i][j]+1,j);
printf("%d--%d %d--%d\n",i,s[i][j],s[i][j]+1,j);
}
void fun()
{
int i,j,k,r;
for (i=0;i<=n;i++)
m[i][i]=0;
for (r=2;r<=n;r++)
{       //相当于每次分的段大小
for (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 (k=i+1;k<j;k++){
int temp=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
if (temp<m[i][j])
m[i][j]=temp;
s[i][j]=k;
}
}
}
}
int main()
{
int i;
while (~scanf("%d",&n))
{
memset(m,0,sizeof(m));
memset(s,0,sizeof(s));
memset(p,0,sizeof(p));
for (i=0;i<=n;i++)
scanf("%d",&p[i]);       //输入
fun();
printf("%d\n",m[1]
);
show(1,n);
}
return 0;
}/*
6
30 35 15 5 10 20 25
结果：15125
*/

递归方案：

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
#define M 101
int n,val[M],dp[M][M],ans,path[M][M];
void show(int i,int j)
{
if (i==j)
return;
show(i,path[i][j]);
show(path[i][j]+1,j);
printf("%d--%d %d--%d\n",i,path[i][j],path[i][j]+1,j);
}
int dfs(int s,int e)
{
int k;
if (s==e)
return 0;
int ans=dfs(s+1,e)+val[s-1]*val[s]*val[e];
path[s][e]=s;
for (k=s+1;k<e;k++)
{
int temp=dfs(s,k)+dfs(k+1,e)+val[s-1]*val[k]*val[e];
ans=min(ans,temp);
}
return ans;
}
int main()
{
int i,j;
scanf("%d",&n);
for (i=0;i<=n;i++)
scanf("%d",&val[i]);
printf("%d\n",dfs(1,n));
show(1,n);
return 0;
}

备忘录方案：

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
#define M 101
int n,val[M],dp[M][M],ans,path[M][M];
void show(int i,int j)
{
if (i==j)
return;
show(i,path[i][j]);
show(path[i][j]+1,j);
printf("%d--%d %d--%d\n",i,path[i][j],path[i][j]+1,j);
}
int dfs(int s,int e)
{
int k;
if (s==e)
return 0;
if (dp[s][e])
return dp[s][e];
int ans=dfs(s+1,e)+val[s-1]*val[s]*val[e];
path[s][e]=s;
for (k=s+1;k<e;k++)
{
int temp=dfs(s,k)+dfs(k+1,e)+val[s-1]*val[k]*val[e];
ans=min(ans,temp);
}
dp[s][e]=ans;
return ans;
}
int main()
{
int i,j;
scanf("%d",&n);
for (i=0;i<=n;i++)
scanf("%d",&val[i]);
printf("%d\n",dfs(1,n));
show(1,n);
return 0;
}