动态规划求最小代价矩阵链相乘

最新推荐文章于 2024-01-07 02:08:01 发布
最新推荐文章于 2024-01-07 02:08:01 发布
阅读量3.5k 收藏 3
点赞数
分类专栏： 算法思维和数据结构 C++ 文章标签： matrix ini c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/emaste_r/article/details/7044055
版权

/*

在2014.3.20进行修改

修改内容1：

主要是改版下，以前的格式在某次CSDN抽风后，都没了，本来应该格式很好看的。

修改内容2：

竟然出bug了，在MATRIX_CHAIN_ORDER()中的：

 for(int 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;
                }

被我写成了：

 for(int 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;
                }

竟然没人发现，我好失败啊。。

*/


矩阵相乘：


A = m x n
B = n x p
相乘后：C = m x p 
通俗点就是： 
for i -> m
	for j -> p
		C[i,j] = 0
		for k -> n
			C[i,j] += A[i,k] * B[k,j]

文艺点就是： 
MATRIX_MULTIPLY (A,B)
if columns[A] != rows[B]
	then error "incompatible dimensions"
else 
	for i = 1 to rows[A]
		for j = 1 to columns[B]
			C[i,j] = 0
			for k = 1 to columns[A]
				C[i,j] = C[i,j]+A[i,k]*B[k,j]
return C

稍微用C++实现了下就是：

/*Ouyang code for test MATRIX_MULTIPLY*/
#include <iostream>
#include "stdio.h"
#define N 4
using namespace std;
void Matrix_Multiply(int A[][N],int B[][N])
{
    int C[N][N];
    for(int i=0;i<N;i++)
        for(int j=0;j<N;j++)
        {
            C[i][j]=0;
            for(int k=0;k<N;k++)
            {
                C[i][j]+=A[i][k]*B[k][j];
            }
        }
    for(int i=0;i<N;i++)
    {
        for(int j=0;j<N;j++)
        {
             printf("%d\t",C[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    int A[4][4]={1,1,1,1,
                 1,1,1,1,
                 1,1,1,1,
                 1,1,1,1};
    int B[4][4]={1,1,1,1,
                 1,1,1,1,
                 1,1,1,1,
                 1,1,1,1};
    Matrix_Multiply(A,B);
    return 0;
}
/*code end*/



时间开销


从上面的算法看出，每次矩阵相乘，就是一个三循环。

对于 A[M,N] 和 B[N,P] ，时间开销就是 MNP



多矩阵相乘的顺序决定了时间开销大小


A[10][100] B[100][5] C[5][50] 三个矩阵相乘

如果是(AB)C 则是10*100*5 + 10*5*50== 5000 + 2500 =7500
如果是A(BC) 则是100*5*50 + 10*100*50== 25000 + 50000 =75000
时间开销相差了 10 倍！

于是就有了这个课题：最小代码矩阵链相乘！




动态规划第一步：最优子结构


很明显，矩阵链Ai * Ai+1 * Ai+2 * Ai+3 * Ai+4 ...Aj 必然归结在在Ai...k与Ak+1...j之间相乘，其中k为i，j之间的下标。
所以矩阵链AiAi+1...Aj的最优加全部括号为(AiAi+1...Ak)*(Ak+1Ak+2...Aj)

其中(AiAi+1...Ak)，(Ak+1Ak+2...Aj)也是最优加全部括号，

可用反证法证明之:

如果它们不是最优的，那么存在一个最优的让它们相乘后的矩阵链是比最优的还最优，矛盾。


动态规划第二步：求一个递归解


设m[i,j]为计算矩阵Ai...j所需要的乘法运算次数最小值，也就是说A1..n的最小代价是m[1，n]。

m[i,j]就等于计算子乘积Ai..k以及Ak+1..j各自的代价加上两者相乘后的代价：pi-1pkpj。

此时我们并不知道k为何值，但是知道k在i...j之间。

m[i,j] = {
           0, i == j;
           min{m[i,k]+m[k+1,j]+pi-1pkpj}  ,i<j;  
 }


动态规划第三步：计算最优代价


输入

假设矩阵Ai的维数是pi-1*pi，i=1,2,3，...n.输入一个序列p={p0,p1,p2,p3...pn},其中length[p] == n+1.

使用一个辅助表m[1..n,1..n]来保存m[i,j]的代价

使用辅助表s[1..n,1..n]来记录计算m[i,j]取得最优代价处k的值。

我们将利用表格s来构造一个最优解。

MATRIX_CHAIN_ORDER(p)
	n = length[p]-1
	for i = 1 to n //初始化代价表
		m[i,i] = 0    //因为长度为1的链不需计算，最小代价为0
	for l = 2 to n        //l为链的长度，从链长度为2一直到n，算完n就得到结果了 
		for i = 1 to n-l+1
			j = i+l-1
	     		m[i,j] = 正无穷
	     		for k = i to j-1
	   			q = m[i,k]+m[k+1,j]+pi-1pkpj;
	      			if q < m[i,j] //不是最小，替换
					m[i,j] = q
	       				s[i,j] = k
	return m,s

这么理解，依次：

链长度为2的各个最优状态

链长度为3的各个最优状态

链长度为4的各个最优状态

链长度为5的各个最优状态

...

链长度为n的各个最优状态

当前的状态被之前的状态所决定。


简单的C++大概是这样：

/*ouyang's code*/
void MATRIX_CHAIN_ORDER(int p[])
{
    int n=length;
    int m[length][length];
    int s[length][length];
    for(int i=1;i<=n;i++) //长度为1的链代价是0
    {
        m[i][i]=0;
    }
    for(int l=2;l<=n;l++) //自底向上m[i,j]增长，l为链的长度，逐步增长
    {
        for(int i=1;i<=n-l+1;i++)
        {
            int j=i+l-1;
            m[i][j]=MAX;
            for(int 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; //记录最小代价的m
                    s[i][j]=k; //记录最小代价时的k
                }
            }
        }
    }
}
/*code end*/



动态规划第四步：构造一个最优解


PRINT_OPTIMAL_PARENS(s,i,j)
	if i == j
		print "A"+i
	else 
		print "("
		PRINT_OPTIMAL_PARENS(s,i,s[i,j]);         
		PRINT_OPTIMAL_PARENS(s,s[i,j]+1,j);
		print ")"


简单的C++代码：

/*ouyang's code*/
void PRINT_OPTIMAL_PARENS(int s[][length+1],int i,int j)
{
    if (i == j)
    {
       printf("A%d",i);
    }
    else
    {
        printf("(");
        PRINT_OPTIMAL_PARENS(s,i,s[i][j]);
        PRINT_OPTIMAL_PARENS(s,s[i][j]+1,j);
        printf (")");
    }
}
/*code end*/



全部代码

/*ouyang's all code */
#include <iostream>
#include "stdio.h"
#define N 4
#define length 6
#define MAX 65000

using namespace std;

int s[length+1][length+1];

void MATRIX_CHAIN_ORDER(int p[])
{
    int n=length;
    int m[length+1][length+1];
    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]=MAX;
            for(int 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;
                }
            }
            cout<<i<<","<<j<<","<<m[i][j]<<endl;
        }
    }
}

void PRINT_OPTIMAL_PARENS(int s[][length+1],int i,int j)
{
        //递归调用，打印矩阵加全部括号的顺序
        if (i == j)
        {
                printf("A%d",i);
        }
         else
         {
                printf("(");
                PRINT_OPTIMAL_PARENS(s,i,s[i][j]);
                PRINT_OPTIMAL_PARENS(s,s[i][j]+1,j);
                printf (")");
         }
}


int main()
{
    /*这个程序是为了得到最小代价的矩阵链乘法，所以结果只是得到怎么去相乘矩阵
      而没有去计算矩阵相乘最后的矩阵。
    */
    int p[length+1]={30,35,15,5,10,20,25};
    MATRIX_CHAIN_ORDER(p);
    PRINT_OPTIMAL_PARENS(s,1,6);
    return 0;
}
/*code end*/




ouyangbro
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
矩阵相乘问题的动态规划
01-04
矩阵相乘问题的动态规划，动态规划是解决多阶段决策过程最优化问题的一种方法，其思想是将求解的问题一层一层地分解成一级一级的子问题，子问题的求解由繁到简逐步缩小，直到可以直接解出子问题为止。下面用动态规划...
动态规划【最小代价爬楼梯】
周小兔的大管家的博客
02-12 144
给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。请你计算并返回达到楼梯顶部的最低花费。示例 1：输入：cost = [10,15,20]输出：15解释：你将从下标为 1 的台阶开始。输入：cost = [1,100,1,1,1,100,1,1,100,1]输出：6解释：你将从下标为 0 的台阶开始。来源：力扣（LeetCode）
动态规划-最小调整代价
李的博客
06-20 666
class Solution { public: /* * @param A: An integer array * @param target: An integer * @return: An integer */ int MinAdjustmentCost(vector &A, int target) { // write your code here vector<vecto...
矩阵链乘最小代价（动态规划）
crazy___1024的博客
11-07 659
矩阵链乘最小代价 先来聊聊思路，首先预备知识是矩阵的相乘，若暂时没学过，那得看看矩阵是如何做乘法的。 假设我们已经知道矩阵是如何相乘的，那么然后我们可以从一个实例出发：有四个矩阵，为了偷懒我们给它们取名为：A1，A2，A3，A4。 其中： A1为4行5列的矩阵 A2为5行7列的矩阵 A3为7行3列的矩阵 A4为3行9列的矩阵 我们有很多种做乘法的方式，例如：（（（A1A2）A3）A4）等，就不一个一个列举了。回到这个问题，（（（A1A2）A3）A4）的乘法次数为多少？ 我们
动态规划之矩阵连乘最优化问题
JingYi的专栏
10-01 2325
动态规划之矩阵连乘最优化问题
机器学习笔记（二）
kuyuguoheqi的博客
07-12 1280
留出法 直接将数据集划分为两个互斥的集合，2/3-4/5。划分原则：划分过程尽可能保持数据分布的一致性方法缺陷：训练集过大，更接近整个数据集，但是由于测试集较小，导致评估结果缺乏稳定性；测试集大了，偏离整个数据集，与根据数据集训练出的模型差距较大，缺乏保真性。交叉验证法 将数据集划分为k个大小相似的互斥子集，每个子集轮流做测试集，其余做训练集，最终返回这k个训练结果的均值。优点：更稳定，更具准确定；缺单：时间复杂的较大自助法 包含m个样本的数据集D，对D进行随机抽样构建D’（抽取m次）,然后将抽到的数据对象
矩阵链相乘算法
08-28
用C++实现的矩阵链相乘算法，并包含大量的注释，对理解程序很有帮助
动态规划求解矩阵链乘
07-02
动态规划求解矩阵链乘
动态规划解决矩阵链乘法问题
12-05
关于运用动态规划解决矩阵链乘法问题的具体步骤
矩阵链相乘的最小乘法次数及乘法方式
05-27
用动态规划策略求矩阵链相乘的最小乘法次数及乘法方式
算法中搜索的艺术
分享学习的知识，记录我的技术成长道路
11-30 908
前言 搜索的问题一般分为两种，一种是在逐层建立起来的二叉树中搜索某一个值的问题，另一种就是搜索最短路径的问题。 基本的搜索策略 广度优先搜索 广度优先搜索的步骤 广度优先搜索与深度优先搜索都是对含有要搜索值的二叉树的搜索。 1.构造根组成 ...
不平衡数据的机器学习
皮皮blog
09-26 1万+
不平衡数据的场景出现在互联网应用的方方面面，如搜索引擎的点击预测（点击的网页往往占据很小的比例），电子商务领域的商品推荐（推荐的商品被购买的比例很低），信用卡欺诈检测，网络攻击识别等等。问题定义那么什么是不平衡数据呢？顾名思义即我们的数据集样本类别极不均衡，以二分类问题为例，假设我们的数据集是$S$，数据集中的多数类为$S_maj$，少数类为$S_min$，通常情况下把多数类样本的比例为$100:
机器学习——代价敏感错误率与代价曲线
淼淼不暴躁!
10-27 1326
首先，你需要明确定义每种错误分类的代价。代价矩阵（cost matrix）是一个二维矩阵，其中的每个元素表示将真实类别i的样本错误地分类为类别j的代价。这个矩阵应该根据你的问题领域和需求来定义。
代价矩阵和混淆矩阵_什么是混淆矩阵以及如何使用它
weixin_26750481的博客
08-27 2957
代价矩阵和混淆矩阵 什么是混淆矩阵？ (What is the Confusion Matrix?) After building the machine learning model, we want to know how our model is doing. Can the model classify correctly or not. We do that by using a con...
浅谈贪心法与TSP问题
weixin_44914711的博客
06-30 3099
贪心法 贪心法把一个复杂问题分解为一系列较为简单的局部最优选择，每一步选择都是对当前解的一个扩展，直到获得问题的完整解。贪心法的典型应用是求解最优化问题，而且对许多问题都能得到整体的最优解，即使不能得到整体最优解，通常也是最优解的很好近似。 TSP TSP问题是指旅行家要旅行n个城市，要求各个城市经历且仅经历一次然后回到出发城市，并要求所走的路程最短。（下面以给出无向图的代价矩阵为例，从左到右，从...
机器学习评价指标
热门推荐
weixin_39910711的博客
10-05 1万+
目录 1 分类 1.1精确率与召回率 1.2 ROC和AUC 1.3对数损失 1.4 铰链损失（Hinge loss） 1.5混淆矩阵 1.6kappa系数 1.7 准确率 1.8海明距离 1.9杰卡德相似系数 1.10多标签排序 1.10.1涵盖误差 1.10.2 标签排序平均精度 1.10.3 排序误差 2拟合 2.1平均绝对误差 2.2...
深入探讨：代价敏感矩阵在推荐系统中的卓越表现
最新发布
禅与计算机程序设计艺术
01-07 394
1.背景介绍 在当今的大数据时代，推荐系统已经成为了互联网公司的核心业务之一，它能够根据用户的历史行为、兴趣和需求，为用户推荐相关的商品、服务或内容。随着用户数据的增长和复杂性，传统的推荐算法已经不能满足现实中的需求。因此，研究者们不断地探索和提出新的推荐算法，以满足不断变化的用户需求。 在这篇文章中，我们将深入探讨一种名为“代价敏感矩阵”(Cost-Sensitive Matrix，CSM)...
机器学习模型性能评估（三）：代价曲线
机器学习算法那些事
11-09 5932
上文详细介绍了P-R曲线与ROC曲线的性能评估方法，P-R曲线与ROC曲线是基于均等损失代价的模型性能评估方法，本文承接上文，详细介绍基于非均等损失代价的模型性能评估方法，并对已介绍的性能评估方法进行了总结。 2.4 代价敏...
代价矩阵和混淆矩阵_对混淆矩阵感到困惑
weixin_26704853的博客
09-07 1317
代价矩阵和混淆矩阵Confusion matrix is an N*N matrix (N = number of target classes) consisting a count of predicted and actual target values. It helps in evaluating the performance of a classification model. 混淆...
动态规划解决矩阵相乘
10-14
动态规划可以用来解决矩阵相乘的问题。具体来说，我们可以定义一个二维数组dp，其中dp[i][j]表示从第i个矩阵到第j个矩阵相乘所需的最小代价。然后，我们可以使用递推的方式来计算dp数组中的每个元素，最终得到dp[n]...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值