精华内容
下载资源
问答
  • 动态规划矩阵连乘
    千次阅读
    2018-06-18 20:47:05

    习要学的,博客是要写的,怪兽是要慢慢打的。

    给定n个人矩阵{A1,A2,·······,An},其中,Ai与Ai+1是可乘的,i=1,2,3,····n-1。考查矩阵的连乘积A1,A2,····An。由于矩阵乘法满足结合律,故计算矩阵的连乘积可以有多种不同的计算次序。  次序由加括号的方式来确定。

    m=[[0,0,0,0,0],#储存计算最优值
       [0,0,0,0,0],
       [0,0,0,0,0],
       [0,0,0,0,0],
       [0,0,0,0,0]
       ]
    s=[[0,0,0,0,0],#储存最佳分开位置
       [0,0,0,0,0],
       [0,0,0,0,0],
       [0,0,0,0,0],
       [0,0,0,0,0]
       ]
    p=[2,3,4,5,6]
    r=2
    n=4
    while(r<=n):#按列循环
        i=1
        while(i<=(n-r+1)):#按行循环
            j=i+(r-1)
            m[i][j]=m[i][i]+m[i+1][j]+p[i-1]*p[i]*p[j]
            s[i][j]=i
            k=i+1
            while(k<j):#行内找出最优解,并存入mzho
                t= m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j]
                if t<m[i][j] :
                    m[i][j]=t
                    s[i][j]=k
                k+=1
            i+=1
        r+=1
    row=0
    
    
    while (row<=4):
        print(s[row])
       
        row+=1
    row=0
    while (row<=4):
        print(m[row])
       
        row+=1
    def traceback(i,j):
        if i==j:
            return
        traceback(i,s[i][j])
        traceback(s[i][j]+1,j)
        print("A %d, %d * A%d, %d" %(i,s[i][j],s[i][j]+1,j))
    traceback(1,4)

    更多相关内容
  • 动态规划算法中矩阵连乘的实现代码,主要是用C语言编写;
  • 主要介绍了C语言矩阵连乘 (动态规划)详解的相关资料,需要的朋友可以参考下
  • 动态规划矩阵连乘c++

    2022-03-30 21:05:40
    矩阵连乘法 //维数分别为10*100 , 100*5 , 5*50 // 按此顺序计算需要的次数 // ((A1*A2)*A3):10X100X5+10X5X50=7500次, //按此顺序计算需要的次数 // (A1*(A2*A3)):10*5*50+10*100*50=75000次 //ai*(bi*bj

    **//参考:
    // https://www.cnblogs.com/henuliulei/p/10074465.html
    //https://www.jianshu.com/p/59f6fac01315

    //维数分别为10100 , 1005 , 550
    // 按此顺序计算需要的次数
    // ((A1
    A2)A3):10X100X5+10X5X50=7500次,
    //按此顺序计算需要的次数
    // (A1
    (A2A3)):10550+1010050=75000次
    //ai
    (bibjcj)[ci==bj] (aibibj)(ci*cj)
    //
    //计算矩阵链A[i:j]的最佳方式应在矩阵Ak和Ak+1之间断开,
    即最优的加括号方式应为(A[i:k])(A[k+1:j)
    //核心思想:
    //对于子问题存在相互交叉的问题,中间结果可能被计算多次,
    // //对于矩阵:记录不同子段长的矩阵乘结果!!!!!!!!!!!
    //最简单的办法是:用一个全局数组记录,之后再查表即可。
    //而真正的动态规划不止这个特点,还有一个特点,自底向上的计算方法,递归是自顶向下。
    //从短的子段开始相乘!!!!!!n(矩阵总个数)>=r>=2
    //
    //
    **

    #include<bits/stdc++.h>
    using namespace std;
    
    void JuZhen(int n,int arr[],int x[][100],int m[][100]);
    void JuZhen(int n,int arr[],int x[][100],int m[][100])
    {
    	for (int t = 1; t <=n; t++)
    	{
    		m[t][t] = 0;
    	}
    	for(int r=2;r<=n;r++)//分为r>=2长度的子部分矩阵段相乘,r=1,结果为零即对角线
    		for (int i = 1; i <= n-r+1; i++)//起始位置第i行,截至位置判断
    		{
    			int j = i + r-1;//[i,j]的个数是r,j<=n,i<=n+1-r!!!!!
    			m[i][j] = m[i + 1][j] + arr[i - 1] * arr[i] * arr[j];//因为m[i][i]=0
    			x[i][j]=i;//!!!!
    			for (int k = i + 1; k<j; k++)
    			{
    				int t = m[i][k] + m[k + 1][n] + arr[i - 1] * arr[k] * arr[j];
    				if (m[i][j] > t)
    				{
    					m[i][j] = t;
    					x[i][j] = k;//记录k的值
    				}
    			}
    		}
    }
    void Traceback(int i,int j,int x[][100])
    {
    	if (i == j)
    		cout << "A" << i;
    	else
    	{
    		cout << "(";
    		Traceback(i, x[i][j],x);
    		Traceback(x[i][j] + 1, j,x);
    		cout << ")";
    	}
    }
    int main()
    {
    	int m[100][100] = {0};
    	memset(m,0,sizeof(m));
    	int n=6;//矩阵个数
    	//cin >> n;
    
    //	memset(arr,0,sizeof(arr));
    	int	arr[]={30,35,15,5,10,20,25};
    	int x[100][100];
    	memset(x,0,sizeof(x));
    	JuZhen(n,arr,x,m);
    
    	cout<<"最后结果为:"<<m[1][n]; 
    	Traceback(1,n,x);
    	//destroyAllWindows();
    }
    
    

    Dev c++实现
    在这里插入图片描述

    展开全文
  • 主要介绍了动态规划矩阵连乘问题Python实现方法,较为详细的分析了矩阵连乘问题的概念、原理并结合实例形式分析了Python相关实现技巧,需要的朋友可以参考下
  • 动态规划 矩阵连乘.pptx
  • 动态规划矩阵连乘求最优值和最优解
    • 问题描述

    矩阵相乘最重要的方法是一般矩阵乘积。它只有在第一个矩阵的列数和第二个矩阵的行数相同时才有意义。给定n个矩阵:A1,A2,...,An,其中Ai与Ai+1是可乘的,i=1,2...,n-1。确定计算矩阵连乘积的计算次序,使得依此次序计算矩阵连乘积需要的数乘次数最少。比如A1(10*100),A2(100*5),A3(5*50)三个矩阵,相乘次序分别为((A1*A2)A3)和(A1(A2*A3))时,矩阵相乘的次数分别为750010*100*5+10*5*50和75000(100*5*50+100*50*10),所以我们需要找到相乘次数最少的矩阵相乘次数(最优值)和矩阵相乘次序(最优解)。

    • 基本思路

    递归公式

    m[i][j]=m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]

    这里的i是第一个相乘矩阵的序列数,j是最后一个所乘的矩阵序列数,其中k是最后一次相乘时序列数i到j中间的任意一个断点数。

    m[i][j]存放的是从第i个矩阵到第j个矩阵的矩阵连乘的计算次数

    实例:

    例:现在有六个矩阵相乘,分别是A1、A2、A3、A4、A5、A6,矩阵的行数和列数分别是A1(30,35)、A2(35,15)、A3(15,5)、A4(5,10)、A5(10,20)、A6(20,25),则六个矩阵相乘经过计算解得最优值为:15125,且最优解为(A1*(A2*A3))*((A4*A5)*A6)

    笔算过程如下:

    过程是分层运算的,只有1个矩阵时、有2个矩阵时、有三个矩阵时、、、

     

     

     全部代码如下:

    #include<iostream>
    using namespace std;
    
    int p[100];
    int m[100][100], s[100][100];
    int n;
    //寻找最优值和断点位置
    void matrixchain()
    {
        int i, r, j, k;
    
        //初始化数组
        for (i = 0; i < 100; i++)
        {
            for (j = 0; j < 100; j++)
            {
                m[i][j] = 0;
                s[i][j] = 0;
            }
    
        }
    
        for (r = 2; r <= n; r++)//矩阵连乘的规模为r,此时计算的矩阵连乘的个数是r个且是顺序连续并所有的。从2开始,因为只有一个矩阵相乘的次数为0。
        {
            for (i = 1; i <= n - r + 1; i++)//第一个矩阵的下标范围
            {
                j = i + r - 1;//最后一个矩阵的下标范围
                m[i][j] = m[i + 1][j] + p[i - 1] * p[i] * p[j];//因为m[i][i]为0,先对m[i][j]赋一个在该位置(第一个断点位置)相连乘的值
                s[i][j] = i;//s[][]存储各子问题的决策点,前面m里面存的是在第一个断点位置的值,所以这里存1
                for (k = i + 1; k < j; k++)//寻找在最优位置断点的最优值
                {
                    int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
                    if (t < m[i][j])
                    {
                        m[i][j] = t;//将最优值赋给m
                        s[i][j] = k;//记录断点位置
                    }
                }
            }
        }
    }
    //寻找最优解
    void print(int i, int j)
    {
        if (i == j)
        {
            cout << "A[" << i << "]";
            return;
        }
    
        cout << "(";
        print(i, s[i][j]);
        cout << "*";
        print(s[i][j] + 1, j);
        cout << ")";
    }
    
    int main()
    {
        cout << "请输入矩阵的个数n : " << endl;
        cin >> n;
        int i, j;
        cout << "请依次输入每个矩阵的行数和最后一个矩阵的列数:" << endl;
        for (i = 0; i <= n; i++)
            cin >> p[i];//将第一个矩阵的列和第二个矩阵的行的下标置为相同的了
        matrixchain();
        cout << "最优值为:" << m[1][n] << endl;
        cout << "最优解计算方法为:";
        print(1, n);
        cout << endl;
        return 0;
    }

    结果如图:

     

    展开全文
  • #include <iostream> using namespace std; #define N 7 int MatrixChain(int *p,int n,int m[][N],int s[][N]) { for(int i=1;i<=n;i++){ m[i][i]=0; } ... m[i][j]=m[i][i]+m
    #include <iostream>
    
    using namespace std;
    
    #define N 7
    int MatrixChain(int *p,int n,int m[][N],int s[][N])
    {
    	for(int i=1;i<=n;i++){
    		m[i][i]=0;
    		
    	}
    	for(int r=2;r<=n;r++){
    		for(int i=1;i<=n-r+1;i++){
    			int j=i+r-1;
    			m[i][j]=m[i][i]+m[i+1][j]+p[i-1]*p[i]*p[j];
    			s[i][j]=i;
    			for(int k=i+1;k<j;k++){
    				int t=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
    				if(t<m[i][j]){
    					m[i][j]=t;
    					s[i][j]=k;
    				} 
    			}
    		}
    	}
    }
    
    void Traceback(int i,int j,int s[][N]){
    	if(i==j){
    		cout<<"A"<<i;
    		
    	}
    	else{
    		cout<<"(";
    		Traceback(i,s[i][j],s);
    		Traceback(s[i][j]+1,j,s);
    		cout<<")"; 
    	}
    }
    int main()
    {
    	int p[N]={30,35,15,5,10,20,25};
    	int m[N][N],s[N][N];
    	MatrixChain(p,N-1,m,s);
    	Traceback(1,6,s);
    	return 0;
    	
        
    }
    
    展开全文
  • 动态规划矩阵连乘算法.doc
  • 动态规划矩阵连乘算法.docx
  • 关于动态规划矩阵连乘的心得体会

    千次阅读 2017-06-15 19:52:05
    矩阵连乘问题动态规划算法  /* Name: 矩阵连乘问题动态规划算法  Copyright:  Author:cc  Date: 16/05/17 20:18 Description: 对于输入的子串30,35,15,5,10,20,25,首先自低向上由最优解包含着子问题的最优解...
  • 动态规划矩阵连乘

    2022-03-25 20:26:21
    动态规划算法之矩阵连乘问题思路_额di个神的博客-CSDN博客_矩阵连乘问题 问题描述: 给定n个矩阵,相连的两个是可乘的。如何确定计算矩阵连乘的计算次序,使得该次序计算矩阵连乘积需要的数乘次数最少。 分析: ...
  • 动态规划矩阵连乘

    2021-03-15 21:16:43
    如何确定计算矩阵连乘积的计算次序,使得依此次序计算矩阵连乘积需要的数乘次数最少。例如,给定三个连乘矩阵{A1,A2,A3}的维数分别是10*100,100*5和5*50,采用(A1A2)A3,乘法次数为10*100*5+10*5*50=7500次,而...
  • 动态规划问题,基本要素是最优子结构性质,子问题重叠性质,自底向上的求解方法。只要了解了基本要素,那么这种题型也会更好理解。本题有不少注释,便于读者阅读。
  • } printf("矩阵的最少计算次数为:%d\n",RecurMatrixChain(1,6,s,p)); printf("矩阵最优计算次序为:"); Traceback(1,6,s); return 0; } //*/ int RecurMatrixChain(int i,int j,int **s,int *p) { int k; int u;...
  • 通过动态规划算法减少矩阵连乘所需的乘法次数。
  • 动态规划自底向上分析图: 这里需要注意:题目要求的仅仅是结合律 而没有要求交换律。所以判断是否可,并不需要单独去判断。在递归的过程中如果出现前面一个矩阵的j和下一个矩阵的i不相同,则说明不可。 ...
  • 如何确定计算矩阵连乘积的计算次序,使得依此次序计算矩阵连乘积需要的数乘次数最少。 要求:给定由n个矩阵构成的序列{A1,A2,…,An},对乘积A1A2…An,找到最小化乘法次数的加括号方法。 二.问题的解决方案/...
  • 动态规划简介 动态规划算法与分治法类似,其基本思想也是将待求解问题分解成若干个子问题,先求解子问题,然后从这些子问题的解得到原问题的解。 与分治法不同的是,适合于用动态规划求解的问题,经分解得到子问题...
  • 考察两个矩阵相乘的情形:C=AB。如果矩阵A,B分别是????×????p×r和????×????...如果有至少3个以上的矩阵连乘,则涉及到乘积次序问题,即加括号方法。例如3个矩阵连乘的加括号方法有两种:((...
  • cout连乘的最少次数是" } 代码(2) #include using namespace std; #define MAX 0xfffffff #define N 100 int n; int p[N]; int s[N][N],dp[N][N]; //S存储切割位置,dp存储最优值 void MatricChain(){ for(int...
  • 动态规划求解矩阵连乘问题

    千次阅读 2021-05-25 05:31:16
    题目给定n个矩阵{A1,A2,…,An}(其中,矩阵Ai的维数为pi-1*pi,i=1,2,3,…,n),如何确定计算矩阵的连乘积A1,A2,…,An的计算次序(完全加括号方式),使得此次序计算矩阵连乘积需要的数乘次数最少。步骤分析最优...
  • 动态规划 矩阵连乘 c++实验 计算机算法设计与分析上的
  • 动态规划C语言矩阵连乘Acm acm 采用动态规划来解题
  • 使用c#实现动态规划法——求解矩阵连乘问题,包括GUI和逻辑实现。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,420
精华内容 2,168
关键字:

动态规划矩阵连乘