两个矩阵相乘的计算量

程序实现

[cpp] view plaincopyprint?
  1. //矩阵a和b相乘，p、q分别为a的行和列，q、r分别为b的行和列
  2. void MatrixMultiply(int a[][MAXN], int b[][MAXN], int p, int q, int r)
  3. {
  4. int sum[MAXN][MAXN];
  5. memset(sum, 0, sizeof(sum));
  6. int i, j, k;
  7. //遍历矩阵a的行
  8. for (k = 0; k < p; k++)
  9. {
  10. //遍历矩阵b的列
  11. for (j = 0; j < r; j++)
  12. {
  13. //对应位置相乘
  14. for (i = 0; i < q; i++)
  15. {
  16. sum[k][j] += a[k][i] * b[i][j];
  17. }
  18. }
  19. }
  20. }
//矩阵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之间，其他情况相同。
加括号的过程是递归的。

程序实现

[cpp] view plaincopyprint?
  1. //m数组内存放矩阵链的行列信息
  2. //m[i-1]和m[i]分别为第i个矩阵的行和列（i = 1、2、3...）
  3. int Best_Enum(int m[], int left, int right)
  4. {
  5. //只有一个矩阵时，返回计算次数0
  6. if (left == right)
  7. {
  8. return 0;
  9. }
  10. int min = INF; //无穷大
  11. int i;
  12. //括号依次加在第1、2、3...n-1个矩阵后面
  13. for (i = left; i < right; i++)
  14. {
  15. //计算出这种完全加括号方式的计算次数
  16. int count = Best_Enum(m, left, i) + Best_Enum(m, i+1, right);
  17. count += m[left-1] * m[i] * m[right];
  18. //选出最小的
  19. if (count < min)
  20. {
  21. min = count;
  22. }
  23. }
  24. return min;
  25. }
//m数组内存放矩阵链的行列信息
//m[i-1]和m[i]分别为第i个矩阵的行和列（i = 1、2、3...）
int Best_Enum(int m[], int left, int right)
{//只有一个矩阵时，返回计算次数0if (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个矩阵的完全加括号方式
可以看到黄色方块中有很多重复计算，所以利用备忘录来保存计算结果，在每次进行计算前，
先查表，看是否计算过，避免重复计算。

程序实现

[cpp] view plaincopyprint?
  1. #include <iostream>
  2. #include <cstdio>
  3. #include <cstring>
  4. using namespace std;
  5. #define SIZE 100
  6. #define INF 999999999
  7. int memo[SIZE][SIZE];
  8. //m数组内存放矩阵链的行列信息
  9. //m[i-1]和m[i]分别为第i个矩阵的行和列（i = 1、2、3...）
  10. int Best_Memo(int m[], int left, int right)
  11. {
  12. //只有一个矩阵时，返回计算次数0
  13. if (left == right)
  14. {
  15. return 0;
  16. }
  17. int min = INF;
  18. int i;
  19. //括号依次加在第1、2、3...n-1个矩阵后面
  20. for (i = left; i < right; i++)
  21. {
  22. //计算出这种完全加括号方式的计算次数
  23. int count;
  24. if (memo[left][i] == 0)
  25. {
  26. memo[left][i] = Best_Memo(m, left, i);
  27. }
  28. count = memo[left][i];
  29. if (memo[i+1][right] == 0)
  30. {
  31. memo[i+1][right] = Best_Memo(m, i+1, right);
  32. }
  33. count += memo[i+1][right];
  34. count += m[left-1] * m[i] * m[right];
  35. //选出最小的
  36. if (count < min)
  37. {
  38. min = count;
  39. }
  40. }
  41. return min;
  42. }
  43. int main(void)
  44. {
  45. int m[SIZE];
  46. int n;
  47. while (scanf("%d", &n) != EOF)
  48. {
  49. int i;
  50. for (i = 0; i < n; i++)
  51. {
  52. scanf("%d", &m[i]);
  53. }
  54. memset(memo, 0, sizeof(memo));
  55. printf("%d\n", Best_Memo(m, 1, n-1));
  56. }
  57. return 0;
  58. }
#include <iostream>
#include <cstdio>
#include <cstring>using namespace std;#define SIZE 100
#define INF 999999999int memo[SIZE][SIZE];//m数组内存放矩阵链的行列信息
//m[i-1]和m[i]分别为第i个矩阵的行和列（i = 1、2、3...）
int Best_Memo(int m[], int left, int right)
{//只有一个矩阵时，返回计算次数0if (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...）
[cpp] view plaincopyprint?
  1. #include <iostream>
  2. #include <cstdio>
  3. #include <cstring>
  4. using namespace std;
  5. #define SIZE 100
  6. #define INF 999999999
  7. int m[SIZE];        //存放矩阵链的行列信息，m[i-1]和m[i]分别为第i个矩阵的行和列（i = 1、2、3...）
  8. int d[SIZE][SIZE];  //存放矩阵链计算的最优值，d[i][j]为第i个矩阵到第j个矩阵的矩阵链的最优值，i > 0
  9. int Best_DP(int n)
  10. {
  11. //把d[i][i]置为0，1 <= i < n
  12. memset(d, 0, sizeof(d));
  13. int len;
  14. //递归计算矩阵链的连乘最优值
  15. //len = 1，代表矩阵链由两个矩阵构成
  16. for (len = 1; len < n; len++)
  17. {
  18. int i, j, k;
  19. for (i = 1, j = i+len; j < n; i++, j++)
  20. {
  21. int min = INF; //无穷大
  22. for (k = i; k < j; k++)
  23. {
  24. int count = d[i][k] + d[k+1][j] + m[i-1] * m[k] * m[j];
  25. if (count < min)
  26. {
  27. min = count;
  28. }
  29. }
  30. d[i][j] = min;
  31. }
  32. }
  33. return d[1][n-1];
  34. }
  35. int main(void)
  36. {
  37. int n;
  38. while (scanf("%d", &n) != EOF)
  39. {
  40. int i;
  41. for (i = 0; i < n; i++)
  42. {
  43. scanf("%d", &m[i]);
  44. }
  45. printf("%d\n", Best_DP(n));
  46. }
  47. return 0;
  48. }

文章出处：http://blog.csdn.net/code_pang/article/details/8743601

另一篇参考：http://www.cnblogs.com/liushang0419/archive/2011/04/27/2030970.html



第3章 动态规划 矩阵连乘问题相关推荐

  1. 算法设计与分析第4章 动态规划（二）【DP序列问题】

    第3章 动态规划(二)[DP序列问题] 3.2 DP序列问题 (51nod的动态规划教程很不错,讲解很详细,以下分析来自51nod) 1.矩阵取数问题 给定一个m行n列的矩阵,矩阵每个元素是一个正整数 ...

  2. 【笔记】《算法设计与分析（第三版）》-王晓东著-第3章-动态规划

    第3章 动态规划 动态规划算法与分治法类似,其基本思想也是将待求解问题分解成若干个子问题,先求解子问题,然后从这些子问题的解得到原问题的解. 与分治法不同的是,适合于用动态规划法求解的问题,经分解得到 ...

  3. 信息学奥赛一本通（C++版） 第二部分 基础算法 第九章 动态规划

    总目录详见:https://blog.csdn.net/mrcrack/article/details/86501716 信息学奥赛一本通(C++版) 第二部分 基础算法 第九章 动态规划 第一节 动 ...

  4. 算法设计与分析第4章 动态规划（一）【背包问题】

    第3章动态规划(一)[背包问题] 基本思想: 动态规划算法与分治法类似,其基本思想也是将待求解问题分解成若干个子问题,但是经分解得到的子问题往往不是互相独立的.不同子问题的数目常常只有多项式量级.在用 ...

  5. 【数理知识】《矩阵论》方保镕老师-第2章-\lambda 矩阵与 Jordan 标准形

    上一章 回到目录 下一章 第2章-\lambda 矩阵与 Jordan 标准形 2.1 λ\lambdaλ 矩阵 2.1.1 λ\lambdaλ 矩阵的概念 2.1.2 λ\lambdaλ 矩阵在相抵 ...

  6. 算法复习第四章动态规划

    算法复习第四章动态规划 动态规划 TSP问题 0-1bag 动态规划 TSP问题 0-1bag 最长公共子序列不考:

  7. 机试指南第七章-动态规划-笔记及背包问题

    第七章     动态规划 一.递归求解: 递归问题的关键是解决初始值和递推公式,从而将复杂问题分解为简单问题直至初始值对应的极简问题,从而得到答案. 套路:初始值+递归公式. Trick:将求出的值存 ...

  8. 第三章，矩阵，04-分块矩阵

    第三章,矩阵,04-分块矩阵 定义 运算 加法 数乘 转置 乘法 分块对角阵 分块对角阵乘法 分块对角阵行列式 按行列分块 行向量 列向量 行列向量表示的矩阵乘法 例 线性方程组分块表示 玩转线性代数 ...

  9. 第三章，矩阵，06-初等变换与初等矩阵

    第三章,矩阵,06-初等变换与初等矩阵 标准形 初等行变换 初等列变换 初等变换 行阶梯形矩阵 行最简形 标准形 初等矩阵 定义 性质 可逆 等价矩阵 相关定义 行等价 列等价 等价 性质 定理1 定 ...

最新文章

  1. 怎么理解ASM中的Failgroup
  2. 机器智能公司一览图 | 36氪
  3. GitHub高赞：给文字打马赛克=形同虚设，AI看透你一切小心思，已开源
  4. linux命令：xargs
  5. wordpress 独立 php,wordpress怎么把所有文章分类单独在一个页面显示
  6. PHP生成日历（实例详解）
  7. ASP.NET Core 2.2+Quartz.Net 实现Web定时任务
  8. 数据库语言 数据查询_使用这种简单的查询语言开始查询数据
  9. 共用软件现漏洞未修复，一年来美国数十个政府网站在推送色情广告
  10. 三点弯曲弹性模量怎么计算公式_腰背肌锻炼：五点支撑和三点支撑（视频）
  11. 在libevent中服务模型
  12. 区块链 链上脚本、智能合约和Dapp的关系区别
  13. python编写简易木马程序_中国骇客云教你使用Python编写木马程序
  14. E-mark认证是什么？
  15. LTE(4G) ATTACH流程
  16. 什么样的面试更有效？
  17. Docker 之 基操
  18. AndroidStudio打包AAR供Unity使用流程
  19. 大话西游之Office应用实例系列! 16
  20. 基于idea-SSM的在线投稿审稿系统-稿件管理-作者管理-稿件审核(javaweb-php-asp.netC#-j2ee)

热门文章

  1. 【数据结构笔记19】File Transfer的C语言实现，集合的简化表示，按秩归并，路径压缩
  2. android dialog的封装,Android系统Dialog的简单封装
  3. 广度优先搜索c语言矩阵,算法7-6：图的遍历——广度优先搜索 （C++代码）
  4. ue html乱码,UE UTF8 乱码
  5. 无需安装配置,多操作系统支持数据库及性能测试
  6. thymeleaf表达式优先级及表达式简单说明
  7. 计算机ppt板块正文文本动画在哪,《计算机应用基础》统考辅导第章PowerPoint电子演示文稿.ppt...
  8. 树莓派官方支持的Tensorflow版本
  9. VirtualBox扩容失败-Progress state: VBOX_E_NOT_SUPPORTED
  10. Kubernetes Service详解（概念、原理、流量分析、代码）