两个矩阵相乘的计算量
程序实现
- //矩阵a和b相乘,p、q分别为a的行和列,q、r分别为b的行和列
- void MatrixMultiply(int a[][MAXN], int b[][MAXN], int p, int q, int r)
- {
- int sum[MAXN][MAXN];
- memset(sum, 0, sizeof(sum));
- int i, j, k;
- //遍历矩阵a的行
- for (k = 0; k < p; k++)
- {
- //遍历矩阵b的列
- for (j = 0; j < r; j++)
- {
- //对应位置相乘
- for (i = 0; i < q; i++)
- {
- sum[k][j] += a[k][i] * b[i][j];
- }
- }
- }
- }
//矩阵a和b相乘,p、q分别为a的行和列,q、r分别为b的行和列
void MatrixMultiply(int a[][MAXN], int b[][MAXN], int p, int q, int r)
{
int sum[MAXN][MAXN];
memset(sum, 0, sizeof(sum));
int i, j, k;
//遍历矩阵a的行
for (k = 0; k < p; k++)
{
//遍历矩阵b的列
for (j = 0; j < r; j++)
{
//对应位置相乘
for (i = 0; i < q; i++)
{
sum[k][j] += a[k][i] * b[i][j];
}
}
}
}
所以a、b两个矩阵相乘的计算量为p*q*r。
枚举所有完全加括号方式
ABCD四个矩阵连乘
1、(A(BCD))——>(A(B(CD))),(A((BC)D));
2、((AB)(CD))——>NULL;
3、((ABC)D)——>((A(BC)D)),(((AB)C)D);
对于上面四个矩阵来说,枚举方法是:
1、括号加在A和B之间,矩阵链被分为(A)和(BCD);
2、括号加在B和C之间,矩阵链被分为(AB)和(CD);
3、括号加在C和D之间,矩阵链被分为(ABC)和(D);
在第一步中分出的(A)已经不能在加括号了,所以结束;
而(BCD)继续按照上面的步奏把括号依次加在B和C、C和D之间,其他情况相同。
加括号的过程是递归的。
程序实现
- //m数组内存放矩阵链的行列信息
- //m[i-1]和m[i]分别为第i个矩阵的行和列(i = 1、2、3...)
- int Best_Enum(int m[], int left, int right)
- {
- //只有一个矩阵时,返回计算次数0
- if (left == right)
- {
- return 0;
- }
- int min = INF; //无穷大
- int i;
- //括号依次加在第1、2、3...n-1个矩阵后面
- for (i = left; i < right; i++)
- {
- //计算出这种完全加括号方式的计算次数
- int count = Best_Enum(m, left, i) + Best_Enum(m, i+1, right);
- count += m[left-1] * m[i] * m[right];
- //选出最小的
- if (count < min)
- {
- min = count;
- }
- }
- return min;
- }
//m数组内存放矩阵链的行列信息
//m[i-1]和m[i]分别为第i个矩阵的行和列(i = 1、2、3...)
int Best_Enum(int m[], int left, int right)
{
//只有一个矩阵时,返回计算次数0
if (left == right)
{
return 0;
}
int min = INF; //无穷大
int i;
//括号依次加在第1、2、3...n-1个矩阵后面
for (i = left; i < right; i++)
{
//计算出这种完全加括号方式的计算次数
int count = Best_Enum(m, left, i) + Best_Enum(m, i+1, right);
count += m[left-1] * m[i] * m[right];
//选出最小的
if (count < min)
{
min = count;
}
}
return min;
}
备忘录法优化
上图为递归枚举过程,小方块内的1:4代表第1个矩阵至第4个矩阵的完全加括号方式
可以看到黄色方块中有很多重复计算,所以利用备忘录来保存计算结果,在每次进行计算前,
先查表,看是否计算过,避免重复计算。
程序实现
- #include <iostream>
- #include <cstdio>
- #include <cstring>
- using namespace std;
- #define SIZE 100
- #define INF 999999999
- int memo[SIZE][SIZE];
- //m数组内存放矩阵链的行列信息
- //m[i-1]和m[i]分别为第i个矩阵的行和列(i = 1、2、3...)
- int Best_Memo(int m[], int left, int right)
- {
- //只有一个矩阵时,返回计算次数0
- if (left == right)
- {
- return 0;
- }
- int min = INF;
- int i;
- //括号依次加在第1、2、3...n-1个矩阵后面
- for (i = left; i < right; i++)
- {
- //计算出这种完全加括号方式的计算次数
- int count;
- if (memo[left][i] == 0)
- {
- memo[left][i] = Best_Memo(m, left, i);
- }
- count = memo[left][i];
- if (memo[i+1][right] == 0)
- {
- memo[i+1][right] = Best_Memo(m, i+1, right);
- }
- count += memo[i+1][right];
- count += m[left-1] * m[i] * m[right];
- //选出最小的
- if (count < min)
- {
- min = count;
- }
- }
- return min;
- }
- int main(void)
- {
- int m[SIZE];
- int n;
- while (scanf("%d", &n) != EOF)
- {
- int i;
- for (i = 0; i < n; i++)
- {
- scanf("%d", &m[i]);
- }
- memset(memo, 0, sizeof(memo));
- printf("%d\n", Best_Memo(m, 1, n-1));
- }
- return 0;
- }
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define SIZE 100
#define INF 999999999
int memo[SIZE][SIZE];
//m数组内存放矩阵链的行列信息
//m[i-1]和m[i]分别为第i个矩阵的行和列(i = 1、2、3...)
int Best_Memo(int m[], int left, int right)
{
//只有一个矩阵时,返回计算次数0
if (left == right)
{
return 0;
}
int min = INF;
int i;
//括号依次加在第1、2、3...n-1个矩阵后面
for (i = left; i < right; i++)
{
//计算出这种完全加括号方式的计算次数
int count;
if (memo[left][i] == 0)
{
memo[left][i] = Best_Memo(m, left, i);
}
count = memo[left][i];
if (memo[i+1][right] == 0)
{
memo[i+1][right] = Best_Memo(m, i+1, right);
}
count += memo[i+1][right];
count += m[left-1] * m[i] * m[right];
//选出最小的
if (count < min)
{
min = count;
}
}
return min;
}
int main(void)
{
int m[SIZE];
int n;
while (scanf("%d", &n) != EOF)
{
int i;
for (i = 0; i < n; i++)
{
scanf("%d", &m[i]);
}
memset(memo, 0, sizeof(memo));
printf("%d\n", Best_Memo(m, 1, n-1));
}
return 0;
}
动态规划法
以矩阵链ABCD为例
按照矩阵链长度递增计算最优值
矩阵链长度为1时,分别计算出矩阵链A、B、C、D的最优值
矩阵链长度为2时,分别计算出矩阵链AB、BC、CD的最优值
矩阵链长度为3时,分别计算出矩阵链ABC、BCD的最优值
矩阵链长度为4时,计算出矩阵链ABCD的最优值
动归方程:
k为矩阵链断开的位置
d数组存放矩阵链计算的最优值,d[i][j]是以第i个矩阵为首,第j个矩阵为尾的矩阵链的最优值,i > 0
m数组内存放矩阵链的行列信息,m[i-1]和m[i]分别为第i个矩阵的行和列(i = 1、2、3...)
- #include <iostream>
- #include <cstdio>
- #include <cstring>
- using namespace std;
- #define SIZE 100
- #define INF 999999999
- int m[SIZE]; //存放矩阵链的行列信息,m[i-1]和m[i]分别为第i个矩阵的行和列(i = 1、2、3...)
- int d[SIZE][SIZE]; //存放矩阵链计算的最优值,d[i][j]为第i个矩阵到第j个矩阵的矩阵链的最优值,i > 0
- int Best_DP(int n)
- {
- //把d[i][i]置为0,1 <= i < n
- memset(d, 0, sizeof(d));
- int len;
- //递归计算矩阵链的连乘最优值
- //len = 1,代表矩阵链由两个矩阵构成
- for (len = 1; len < n; len++)
- {
- int i, j, k;
- for (i = 1, j = i+len; j < n; i++, j++)
- {
- int min = INF; //无穷大
- for (k = i; k < j; k++)
- {
- int count = d[i][k] + d[k+1][j] + m[i-1] * m[k] * m[j];
- if (count < min)
- {
- min = count;
- }
- }
- d[i][j] = min;
- }
- }
- return d[1][n-1];
- }
- int main(void)
- {
- int n;
- while (scanf("%d", &n) != EOF)
- {
- int i;
- for (i = 0; i < n; i++)
- {
- scanf("%d", &m[i]);
- }
- printf("%d\n", Best_DP(n));
- }
- return 0;
- }
文章出处:http://blog.csdn.net/code_pang/article/details/8743601
另一篇参考:http://www.cnblogs.com/liushang0419/archive/2011/04/27/2030970.html