动态规划法3—矩阵链乘法

Eternal嘉

于 2021-03-31 21:53:43 发布

阅读量434

点赞数 1

分类专栏：算法与数据结构笔记文章标签：算法数据结构

本文链接：https://blog.csdn.net/weixin_51302676/article/details/115360357

版权

算法与数据结构笔记专栏收录该内容

30 篇文章 0 订阅

订阅专栏

动态规划法3—矩阵链乘法

对于给定的几个矩阵，求计算这几个矩阵相乘时进行最少次相乘的运算顺序，这类问题就称为矩阵链乘法。

当 $l\times m$ 的矩阵A和 $m\times n$ 的矩阵B相乘后得到矩阵C，C中各元素为：

$c_{ij}=\sum_{k=1}^{m} a_{ik} b_{kj}$

矩阵A和矩阵B进行的乘法运算次数为 $l\times m\times n$ 。

接下来分析多个矩阵的乘法，比如计算 $M_{1}M_{2}M_{3}M_{4}M_{5}M_{6}$ ,就有多种计算顺序，这些计算顺序得出的结果相同，但是进行的乘法运算次数却不相同。如果检查所有的计算顺序，那么算法复杂度会达到O（ $n!$ ），显然不可能实现。

但是这个问题可以分割成更小的局部问题，所以可以使用之前学到的动态规划法。

$M_{1}M_{2}$ 只有一种计算方法， $M_{2}M_{3}$ 也是一种计算方法，这些相当于已知的结果被存储起来，在需要时可以直接调用，比如求 $M_{1}M_{2}M_{3}$ 就是计算 $(M_{1}M_{2})M_{3}$ 和 $M_{1}(M_{2}M_{3})$ 哪一种计算次数更少，这时当再次遇到 $M_{1}M_{2}M_{3}$ 就可以直接调用刚才得到的计算次数。

假设 $M_{i}$ 的行为 $p_{i-1}$ 列为 $p_{i}$ 那么：

$(M_{1}M_{2})M_{3}$ = $M_{1}M_{2}$ + $M_{3}$ + $p_{0}*p_{2}*p_{3}$

$M_{1}(M_{2}M_{3})$ = $M_{1}$ + $M_{2}M_{3}$ + $p_{0}*p_{1}*p_{3}$

所以综上， $M_{1}M_{2}M_{3}M_{4}M_{5}M_{6}$ 的最优解就是下列式子中的最小值：

$(M_{1})M_{2}M_{3}M_{4}M_{5}M_{6}$

$(M_{1}M_{2})M_{3}M_{4}M_{5}M_{6}$

$(M_{1}M_{2}M_{3})M_{4}M_{5}M_{6}$

$(M_{1}M_{2}M_{3}M_{4})M_{5}M_{6}$

$(M_{1}M_{2}M_{3}M_{4}M_{5})M_{6}$

为了方便计算假设：

m[i][j]	表示计算 $M_{i}M_{i+1}\cdots M_{j}$ 所需的最小次数
p[n]	用来存储矩阵的行列数， $M_{i}$ 的行为 $p_{i-1}$ 列为 $p_{i}$

计算m[i][j]:

m[i][j]
0	i=j
$min_{i\leqslant k\leqslant j} (m[i][k]+m[k+1][j]+p[i-1]\times p[k]\times p[j])$	i<j

void matrixchainmultiplication() {

	for (int i = 1; i <= n) {
		m[i][i] = 0;
	}

	for (int l = 2; l <= n; l++) {    //三重循环
		for (int i = 1; i < n - l + 1; i++) {
			int j = i + l - 1;
			m[i][j] = inf;
			for (int k = i; k <= j - 1; k++) {
				m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
			}
		}
	}
}

完整的代码如下：

#include<iostream>
using namespace std;
#define N 100

int main() {

	int n, p[N],m[N][N];

	cin >> n;

	for (int i = 1; i <= n; i++) {
		cin >> p[i - 1] >> p[i];
	}

	for (int i = 1; i <= n;i++){
		m[i][i] = 0;
	}

	for (int l = 2; l <= n; l++) {
		for (int i = 1; i <= n - l + 1; i++) {
			int j = i + l - 1;
			m[i][j] = (1 << 21);
			for (int k = i; k <= j - 1; k++) {
				m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
			}
		}
	}

	cout << m[1][n] << endl;

	return 0;
}

算法矩阵的数量l从2增加到n，对于每个数量要通过i和j来指定范围，在此范围里还要改变k，三重循环，所以整个算法的复杂度为O（ $n^{3}$ ）。

读《挑战程序设计竞赛》第三十天（侵删）2021.3.31

（ 2021.7.14 第一次修改）

Eternal嘉

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
动态规划法3—矩阵链乘法

动态规划法3—矩阵链乘法对于给定的几个矩阵，求计算这几个矩阵相乘时进行最少次相乘的运算顺序，这类问题就称为矩阵链乘法。当的矩阵A和的矩阵B相乘后得到矩阵C，C中各元素为：矩阵A和矩阵B进行的乘法运算次数为。接下来分析多个矩阵的乘法，比如计算,就有多种计算顺序，这些计算顺序得出的结果相同，但是进行的乘法运算次数却不相同。如果检查所有的计算顺序，那么算法复杂度会达到O（），显然不可能实现。但是这个问题可以分割成更小的局部问题，所以可以使用之前学到的动...
复制链接

扫一扫

专栏目录