对于矩阵连乘机问题就不概述了，主要是找出最佳的结合方式使得整个式子的运算次数最少。

         对于这个问题之所以用动态规划的原因点如下：

         第一：由于矩阵连乘机本身可以划分为若干个子矩阵链连乘机，而且若干个子矩阵链的最优解组合起来就是原矩阵链的最优解。

         第二：对于原矩阵链的不同划分中个子问题是存在重叠子问题。

         所以当此问题用动态规划算法来解决时就会变得很简单，算法的精髓就是从子问题入手、自底向上一步一步的由子问题的最优解去找到更复杂的大问题的最优解，

当循环到原问题时得出即为原为题的最优解；而且在自底向上的过程中应该将各个子问题的解记录在一张表中，以避免之后重复的去计算同一个子问题。个人觉得自底

向上的去记录子问题的解避免重复计算，这是动态规划最大的一个亮点了，不然就和递归分治策略本质上没有太大的区别了。

#include<iostream>
#include<vector>
#include<iterator>
#include<algorithm>
using namespace std;

/*
*矩阵连乘（动态规划非递归）
*/
vector<vector<int>> m;//m[i][j]表示矩阵Ai连乘到Aj的最少运算次数
vector<vector<int>> s;//s[i][j]记录矩阵Ai和矩阵Aj之间的分割点

//计算该连乘式子的最佳结合方式
void MatrixChain(vector<int>& p)
{
	int n = p.size()-1;//一共有n个矩阵相乘
	m = vector<vector<int>>(n+1,vector<int>(n+1,0));//0行0列空余
	s = vector<vector<int>>(n+1,vector<int>(n+1,0));//0行0列空余
	//初始化m数组
	for(int i = 0;i<=n;i++) m[i][i] = 0;
	for(int d = 2;d<=n;d++)//自底向上填表、d:表示矩阵连乘的距离值
		for (int i = 1; i <= n-d+1; i++)//i表示Ai矩阵
		{
			int j = i+d-1;
			//计算m[i][j]
			int k = i+1;
			m[i][j] = p[i-1]*p[i]*p[j]+m[k][j];
			s[i][j] = i;
			for ( k++; k<j ; k++)
			{
				int ini = m[i][k] +p[i-1]*p[k]*p[j]+m[k+1][j];
				if(ini<m[i][j])
				{
					m[i][j] = ini;
					s[i][j] = k;
				}
			}
		}
}

//输出该连乘式子的最佳结合方式
void PrintMatrixChain(int n,int m)
{
	if(n==m)
	{
		cout<<"A"<<n;
		return;
	}
	int k = s[n][m];
	if(n==k)
		PrintMatrixChain(n,k);
	else
	{
		cout<<"(";
		PrintMatrixChain(n,k);
		cout<<")";
	}
	if(k+1==m)
		PrintMatrixChain(k+1,m);
	else
	{
		cout<<"(";
		PrintMatrixChain(k+1,m);
		cout<<")";
	}
}
int main()
{
	vector<int> vec;
	copy(istream_iterator<int>(cin),istream_iterator<int>(),back_inserter(vec));
	MatrixChain(vec);
	PrintMatrixChain(1,vec.size()-1);
}

运行测试：

         输入六个矩阵分别为：A1(50*10)  A2(10*40)  A3(40*30)  A4(30*5)  A5(5*20)  A6(20*15)

         计算A1*A2*A3*A4*A5*A6

         输出的最佳结合方式为：如下图

矩阵连乘（动态规划非递归）