算法导论——矩阵链乘法（显示完全括号方案）

上一个问题：切割钢条

《算法导论》讲解动态规划的第二个问题是矩阵链乘法。
先介绍已经矩阵的相乘：

• 矩阵A：p*q
• 矩阵B：q*r

则两个矩阵相乘所需的乘法次数为pqr；
在多个矩阵A1A2A3A4…An相乘时，由于矩阵乘法满足结合律。所以恰当的运用结合律，可以大大的缩小运算时间。
如，有三个矩阵

• A1：10*100
• A2：100*5
• A3：5*50

先算A1A2：10* 100* 5+10 * 5 * 50=7500
先算A2A3：100* 5* 50+10* 100* 50=75000
在矩阵链长度只有3的时候，不同的结合律已经显示出了10倍的差距，可见选择合适的结合律有多么重要。
现在，用动态规划的方法找出最好的结合律的方案（完全括号法）

现在按照上一篇文章所描述的动态规划方法步骤，来实现这个算法！

1.刻画一个最优解的特征
2.递归的定义最优值
3.计算最优值，通常采用自底向上的方法

1.刻画最优解的结构特征

先寻找到一个最优子结构，当前问题可以由这个最优子结构来表示出来。具体一点，对于一个矩阵链Ai~ Aj找到一个k（i<k<j）——即把i ~ j分为两个部分。使得（A _i ~ A _k）乘（A _k+1 ~ A _j）的结果是最小的。对于（A _i ~ A _k）和（A _k+1 ~ A _j）又可以把他们继续拆分。
此时矩阵链Ai~ Aj相乘的代价可以表示为
m[i,j]=m[i,k]+m[k+1,j]+p_i-1p_kp_j
数组p应矩阵i ~ j的行数，列数；

一个递归的求解方案

经过上述的分析，要找的m[i,j]的最小值，就要遍历i ~ j之间所有的k，m[i,j]可以表示为

1. 0 ---------------------------------- i=j
2. m[i,k]+m[k+1,j]+p_i-1p_kp_j ----- i<j

在对k遍历的过程中，可以将满足条件的k储存在数组s[i] [j]中 。s[i][j]=k,代表在矩阵链i ~ j ，在k处画括号，可以使相乘次数最小。这里由于是自底向上实现的，所以默认m[i][k]和m[k+1][j]是已知的，直接用他们的值来作比较就好了。

代码实现

动态规划核心代码

for (i = 1; i <= n; i++)
		m[i][i] = 0;             //自己乘自己代价为零
	//规划
for (L = 2; L <= n; L++) //从长度为2的开始遍历，即i~j的长度为2
{
	for (i = 1; i <= n - L + 1; i++)
	{
		j = i + L - 1;
		m[i][j] = 100000000;
		for (k = i; k < j; k++)
		{
			int q = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
			if (q < m[i][j])  //不断更新m[i][j]的值，保证他是最小的
			{
				m[i][j] = q;
				s[i][j] = k;
			}
		}
	}
}

显示i ~ j 之间在哪一个点做截断合适

	for (i = 1; i <= n; i++)
	{
		for (j = i; j <= n; j++)
		{
			printf("%d   %d:  %d\n", i, j, s[i][j]);
		}
	}

完整代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int p[7] = {30,35,15,5,10,20,25};
//int p[4] = { 10,100,5,50 };
int m[1000][1000] = { 0 };
int s[1000][1000] = { 0 };
struct node {
	int a;
	int b;
};
struct node num[1000];
void pr(int, int);
void add(int, int, int);
int main()
{
	int n = sizeof(p)/sizeof(int)-1, L, i, j, k;
	for (i = 1; i <= n; i++)
		m[i][i] = 0;             //自己乘自己代价为零
	//规划
	for (L = 2; L <= n; L++)
	{
		for (i = 1; i <= n - L + 1; i++)
		{
			j = i + L - 1;
			m[i][j] = 100000000;
			for (k = i; k < j; k++)
			{
				int q = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
				if (q < m[i][j])
				{
					m[i][j] = q;
					s[i][j] = k;

				}
			}
		}
	}
	add(1, n, s[1][n]);
	printf("%d\n", m[1][n]);
	pr(1, n);
	puts("");
	for (i = 1; i <= n; i++)
	{
		for (j = i; j <= n; j++)
		{
			printf("%d   %d:  %d\n", i, j, s[i][j]);
		}
	}
	for (i = 1; i <= n; i++)
	{
		while (num[i].a != 0)
		{
			num[i].a--;
			printf("(");
		}
		printf("A%d", i);
		while (num[i].b != 0)
		{
			num[i].b--;
			printf(")");
		}
	}
}
void add(int i, int j, int k)
{
	if (j - i <= 0)
		return;
	//在知道了，i,j,k;判断他们三者的距离来决定要不要加括号
	if (k - i > 0)
	{
		num[i].a++;
		num[k].b++;
	}
	if (j - k > 1)
	{
		num[k + 1].a++;
		num[j].b++;
	}
	add(i, k, s[i][k]);
	add(k + 1, j, s[k + 1][j]);
}
void pr(int i, int j)
{
	if (j-i <= 0)
		return;
	else {
		int k = s[i][j];
		printf("%d  ", s[i][j]);
		pr(i, k);
		pr(k + 1, j);
	}
}

开头给了两个测试数据，可以自己尝试更多的测试数据

输出结果

最后介绍一下如何输出完全括号的方案。在算出最终结构之后，调用递归函数
对于相差两个矩阵或以上的添加括号，对于单个矩阵不添加。如（A1A2）A3

void add(int i, int j, int k)
{
	if (j - i <= 0)
		return;
	//在知道了，i,j,k;判断他们三者的距离来决定要不要加括号
	if (k - i > 0)
	{ 
		num[i].a++; //在结构体中a表示i的左边要添加'('
		num[k].b++;//b表示i的右边要添加括号')'
	}
	if (j - k > 1)
	{
		num[k + 1].a++;
		num[j].b++;
	}
	add(i, k, s[i][k]);
	add(k + 1, j, s[k + 1][j]);
}

最后配合输出，打印出完整的方案

	for (i = 1; i <= n; i++)
	{
		while (num[i].a != 0)
		{
			num[i].a--;
			printf("(");
		}
		printf("A%d", i);
		while (num[i].b != 0)
		{
			num[i].b--;
			printf(")");
		}
	}

总结

和切割钢条类似，不须要在一个大问题中考虑很多个子问题，具体在这两个问题中，值需要考虑将一个大问题分为两个子问题，至于更细的划分，他的两个子问题里面已经考虑好了。