动态规划（一）——矩阵连乘

矩阵连乘

题目：给定 n 个矩阵 hA 1 ,A 2 ,…,A n i, 其中 A i 和 A i+1 是可乘的, i = 1,2,…,n − 1. 考虑这 n 个矩阵的连乘积 A 1 × A 2 × ··· × A n 的计算方法?

首先可以暴力枚举，列举所有矩阵连乘的方法所需要的计算量，然后选出最小的那个一个，但是矩阵连乘的方法数很大，可以通过p2函数进行计算，见下列代码。
计算矩阵连乘的方法数的公式为：

int p2(int num)//num为矩阵个数
{
	if(num==1)
	{
		return 1;
	}
	else
	{
		int sum=0;
		for(int i=1;i<num;i++)
		{
			sum+=p2(i)*p2(num-i);
		}
		return sum;
	}
}

然后通过分析可以发现，矩阵连乘问题，一系列矩阵连乘中的最优解包含了子问题的最优解，也就是说A1A2…An的最优解中Ai*…Aj(其中i>1,j<n)一定是最优解，因此可以利用动态规划来解决。

动态规划则需要推导公式，矩阵连乘的公式为：
其中A表示矩阵，m[i,j]表示矩阵i乘到矩阵j的最小的计算量，
s[i,j]表示矩阵i乘到矩阵j确定最优解时对应的k值，k值则表示以第k个矩阵为分隔进行矩阵乘法。
p[i]表示矩阵的列数，p[0]表示第1个矩阵的行数。
首先按照矩阵的规模进行枚举，矩阵乘法规模从2变化到n，然后按照公式计算m[i][j]的值。
输出的时候使用递归进行输出。

完整代码

#include<iostream>
#include<cstring> 
using namespace std;
int n;
const int size =100;
int maxm =10000000;
int p[size];//用来存储矩阵的阶数 
int m[size][size];//计算Aij的最小代价 
int s[size][size];//存储最优的k值 
void matrixchain()
{
	memset(m,0,sizeof(m));
	memset(s,0,sizeof(s));
	//枚举矩阵的规模
	for(int r=2;r<=n;r++)
	{
		for(int i=1;i<=n-r+1;i++)
		{
			int j=i+r-1;
			m[i][j]=maxm; 
			for(int k=i;k<j;k++)
			{
				int tem =m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
				if(tem<m[i][j])
				{
					m[i][j]=tem;
					s[i][j]=k;
				}
			}
		}
	}
}

void print(int i,int j)
{
	if(i == j)
	{
		cout<<"A["<<i<<"]";
		return;
	}
	cout<<"(";
	print(i,s[i][j]);
	print(s[i][j]+1,j);//递归1到s[1][j]
	cout<<")";
}

//计算矩阵连乘的方法数 
int p2(int num)
{
	if(num==1)
	{
		return 1;
	}
	else
	{
		int sum=0;
		for(int i=1;i<num;i++)
		{
			sum+=p2(i)*p2(num-i);
		}
		return sum;
	}
}

int main()
{
	//int su=p(4);
	//cout<<su<<endl;
	cout<<"请输入矩阵的个数n : "<<endl;
	cin>>n;
	int i,j;
	cout<<"请依次输入每个矩阵的行数和最后一个矩阵的列数："<<endl;
	for(i=0;i<=n;i++)
		cin>>p[i];
	matrixchain(); 
	print(1,n);
	cout<<endl;
	cout<<"最小计算量的值为："<<m[1][n]<<endl;
	return 0;
}