算法导论-动态规划之矩阵链乘法

最新推荐文章于 2022-04-22 00:55:31 发布

jiel_

最新推荐文章于 2022-04-22 00:55:31 发布

阅读量836

点赞数

分类专栏：算法文章标签：矩阵递归动态

本文链接：https://blog.csdn.net/jl__nuaa/article/details/46844925

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

这篇博客探讨了如何使用动态规划而非递归解决矩阵链乘法问题，以降低时间复杂度从O(2^n)到O(n^3)。通过辅助空间存储已解决的子问题，避免重复计算，并提供了C++源码实现。

摘要由CSDN通过智能技术生成

原题见PDF204页

动态规划和分治法的区别不在这细说，很容易能够百度查到。主要想详细的记录一下动态规划的求解中不采用递归，而是借助辅助空间来更快的求解。（递归求解时间代价O(2^n),动态规划求解时间代价O(n^3))

A0A1A2A3A4A5

定义：
A[i]的维数为p[i]×p[i+1]
m[i][j]为重A[i]乘到A[j]标量乘法运算的最小次数。(m[i][j]=0,当i==j时)

加入要求解的是m[0][2]，则m[0][2]为m[0][0]+m[1][2]+p[0]p[1]p[3];m[0][1]+m[2][2]+p[0]p[2]p[3]中的最小值。

递归式为：
这里写图片描述

下面通过一个表格来说明如何借助辅助空间实现更快的求解。

这里写图片描述

这个表格可以看成是二维数组m，而我们想要求解A0A1A2A3A4A5的最小乘法运算次数就是求m[0][5];

当我们按照前面的递归去求解m[0][5]时，其实就是在逐渐的把这个表蓝色部分的数据给填完整，在动态求解中有很多的子问题被重复的利用，如果使用递归就会重复的求解，所以使用这样一个辅助空间来存储已经求解过的值，再次使用时所消耗的时间代价只是O(1)，但是需要耗费O(n^2)的空间来存储。但其实二维数组使用到的只是蓝色部分。

在求解这个表中的数据时，应当从左至右求解，我个人理解这就是动态规划里说的从下至上求解。

下面是C++源码：

#include<iostream>

using namespace std;

const int length=6;

void matrixChainOrder(int p[],int m[][length]);
int minNum(int p[],int m[][length],int i,int j);

int main(){
    int p[7]={30,35,15,5,10,20,25};
    int m[length][length];

    for(int i=0;i<length;i++){
        for(int j=0;j<length;j++){
            m[i][j]=0;
        }

    matrixChainOrder(p,m);

    for(int i=0;i<length;i++){
        for(int j=0;j<length;j++){
            cout << m[i][j] << '\t';
            if(j==length-1){
                cout << endl;
            }
        }
    }
}

void matrixChainOrder(int p[],int m[][length]){
    for(int j=0;j<length;j++){
        for(int i=length-1;i>=0;i--){
            if(i>=j){
                continue;
            }
            else{
                m[i][j]=minNum(p,m,i,j);
            }
        }
    }
}

int minNum(int p[],int m[][length],int i,int j){
    int min=1000000;
    for(int n=i;n<j;n++){
        if((m[i][n]+m[n+1][j]+p[i]*p[n]*p[j])<min){
            min=m[i][n]+m[n+1][j]+p[i]*p[n+1]*p[j+1];

        }
    }
    return min;
}