【动态规划】矩阵连乘问题

1. 两个矩阵相乘：

代码如下：

void MatrixMutiply(int** a, int** b, int** c, int ra, int ca, int rb, int cb)
{
	if (ca != rb) return;
	for (int i = 0; i < ra; ++i)   //a的行
	{ 
		int sum = 0;
		for (int j = 0; i < cb; ++j)  //b的列
		{
			for (int k = 0; k < ca; ++k)  //a的列 
			{
				sum = a[i][k] * b[k][j];
			}
			c[i][j] = sum;
		}
	}
}

2. 三个矩阵相乘：

矩阵相乘，只有结合律没有交换律。
显而易见，三个矩阵相乘，有两种结合方式，（AB)C 比 A(BC)的值小的多。

3. 多个矩阵连乘，有多种结合方式

因此我们把它们进行划分，假设从第k个矩阵开始划分。如下图：就有

j个矩阵连乘的积 = R(第 i 个到第k矩阵的积 ) + U(第k+1到最后一个矩阵的积) + R*U 。

举个例子：

有6个矩阵如下图：
使 k = 2 ，则从第二个矩阵开始划分 ，得到如下：

使 k = 4 ，则从第二个矩阵开始划分 ，得到如下：

根据上面两幅图可以看出，红色 绿色 黄色 ，所对应得数组p下标所对应的值正好是R，U相乘需要的行和列。得示例可以得到如下关系：

代码如下：

int MaxtrixMut(int* dp, int i, int j)
{
	if (i == j) return 0;
	else
	{  
		//int t = MaxtrixMut(dp, i, i)+MaxtrixMut(dp,i+1,j)+dp[i-1]*dp[i]*dp[j];  
	    //k == i时
		int t = 0 + MaxtrixMut(dp,i+1,j)+dp[i-1]*dp[i]*dp[j];    
		//从i+1开始划分	
		for (int k = i+1; k < j; ++k)
			{
				int v = MaxtrixMut(dp,i,k)+MaxtrixMut(dp,k+1,j)+ dp[i - 1] * dp[k] * dp[j];	
			    if (t > v)
		   	    {
				  t = v;
		     	}
		     }
		return t;
	}
}

示例：

如果是从第一个到第四个矩阵的乘积，则可以划分为如下：其中红色均为重复划分。

去重以后的代码：

int MaxtrixMut_2(int* dp, int i, int j, vector<vector<int> >& vec)
{
	if (i == j) return 0;
	else if (vec[i][j] > 0)   //判断vec中是否有值
	{
		return vec[i][j];
	}
	else
	{    //k == i时
		 vec[i][j] = 0 + MaxtrixMut_2(dp, i + 1, j,vec) + dp[i - 1] * dp[i] * dp[j];
		//从i+1开始划分	
		for (int k = i + 1; k < j; ++k)
		{
			int v = MaxtrixMut_2(dp, i, k,vec) + MaxtrixMut_2(dp, k + 1, j,vec) + dp[i - 1] * dp[k] * dp[j];
			if (vec[i][j] > v)
			{
				vec[i][j] = v;
			}
		}
		return vec[i][j];
	}
}

运行结果：

int NiceMatrixChain_2(int p[], int n, vector<vector<int> >& m, vector<vector<int> >& s)
{
      ....................................
			m[i][j] = m[i][i] + 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 (m[i][j] > t)
				{
					m[i][j] = t;
					s[i][j] = k;//   划分点
					..............................................
}

了解如何进行划分：代码如下：

按照
12 23 34 45 56
123 234 345 456
1234 2345 3456
12345 23456
123456 划分

void NiceMatrixChain(int p[],int n ,vector<vector<int> > &m)
{
	for (int i = 1; i <= n; ++i) m[i][i] = 0;  //让其对角线置为0  1，1  2，2  3，3  4，4  5，5  6，6
	for (int r = 2; r < n; ++r)   //循环的行数
	{
		for (int i = 1; i <= n - r + 1; ++i)   //循环的列数
		{
			int j = i + r - 1;
			for (int k = i; k <= j; ++k)
			{
				printf("%d", k);
			}
			printf(" ");
		}
		printf("\n");
	}

运行结果如下：

根据上面的代码，略加修改可以得到整个划分的过程。

【举个例子 开始先是 12 23 34 45 56 进行相乘】
而123相乘 可以分为 (12)3 1(23) 则只需要用上面已经得出的12 和 23 分别与矩阵三和矩阵1相乘，并比较处哪个较小。选较小的积。

int NiceMatrixChain_2(int p[], int n, vector<vector<int> >& m)
{
	for (int i = 1; i <= n; ++i) m[i][i] = 0;  //让其对角线置为0  1，1  2，2  3，3  4，4  5，5  6，6
	for (int r = 2; r <= n; ++r)   //循环的行数
	{
		for (int i = 1; i <= n - r + 1; ++i)   //循环的列数
		{
			int j = i + r - 1;
			m[i][j] = m[i][i] + m[i + 1][j] + p[i - 1] * p[i] * p[j];
			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 (m[i][j] > t)
				{
					m[i][j] = t;
				}
			}
			PrintVector(m);
		}
	}
	return	m[1][n];
}

测试代码如下；

int main()
{
	const int n = 6;
	int p[n+1] = { 30,35,15,5,10,20,25 };
//int sum = MaxtrixMut(p, 1, n);
	vector<vector<int> > vec(n+1, vector<int>(n + 1,0));//  int sum = MaxtrixMut_2(p, 1, n, vec);
// PrintVector(vec);
//	cout << sum << endl;
//	NiceMatrixChain(p, n, vec);
	int sum = NiceMatrixChain_2(p, n, vec);
	PrintVector(vec);
}