算法之动态规划 例题之矩阵连乘问题

 

动态规划自底向上分析图：

这里需要注意：题目要求的仅仅是结合律 而没有要求交换律。所以判断是否可乘，并不需要单独去判断。在递归的过程中如果出现前面一个矩阵的j和下一个矩阵的i不相同，则说明不可乘。

经过分析以后，我们通过自底向上的方式完成算法的设计即可。

参考算法1：（据说存在错误）

#include<bits/stdc++.h>
using namespace std;
int N;
int main(){
	while(cin>>N){
		N+=1;
		int tempx,tempy;int p[N+1];int flag=1;
		for(int i=1;i<N;i++){
			cin>>tempx>>tempy;
			if(i==1){
				p[0]=tempx;p[1]=tempy;
			}else{
				if(tempx!=p[i-1]) {
					cout<<"invalid argument"<<endl;
					flag=0;break;
				}
			}
			p[i]=tempy;
		}
	if(flag==0) continue;
	int m[N][N],s[N][N];int length=N;
	int n=length-1,l,i,j,k,q=0;
    //m[i][i]只有一个矩阵，所以相乘次数为0，即m[i][i]=0;
    for(i=1;i<length;i++)
    {
        m[i][i]=0;
    }
    //l表示矩阵链的长度
    // l=2时，计算 m[i,i+1],i=1,2,...,n-1 (长度l=2的链的最小代价)
    for(l=2;l<=n;l++)
    {
        for(i=1;i<=n-l+1;i++)
        {
            j=i+l-1; //以i为起始位置，j为长度为l的链的末位，
            m[i][j]=0x7fffffff;
            //k从i到j-1,以k为位置划分
            for(k=i;k<=j-1;k++)
            {
                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 <<m[1][N-1]<< endl;	
	}
	return 0;
}

参考算法2：运行没问题 但是超时了 说明效率还不够快

//3d1-1 重叠子问题的递归最优解
//A1 30*35 A2 35*15 A3 15*5 A4 5*10 A5 10*20 A6 20*25
//p[0-6]={30,35,15,5,10,20,25}
#include<bits/stdc++.h>
using namespace std; 
int N;
int RecurMatrixChain(int i,int j,int **s,int *p);//递归求最优解
void Traceback(int i,int j,int **s);//构造最优解
int RecurMatrixChain(int i,int j,int **s,int *p){
	if(i==j) return 0;
	int u = RecurMatrixChain(i,i,s,p)+RecurMatrixChain(i+1,j,s,p)+p[i-1]*p[i]*p[j];
	s[i][j] = i;
 
	for(int k=i+1; k<j; k++)
	{
		int t = RecurMatrixChain(i,k,s,p) + RecurMatrixChain(k+1,j,s,p) + p[i-1]*p[k]*p[j];
		if(t<u)
		{
			u=t;
			s[i][j]=k;
		}
	}
	return u;
}
 
void Traceback(int i,int j,int **s)
{
	if(i==j) return;
	Traceback(i,s[i][j],s);
	Traceback(s[i][j]+1,j,s);
	cout<<"Multiply A"<<i<<","<<s[i][j];
	cout<<" and A"<<(s[i][j]+1)<<","<<j<<endl;
}
int main()
{
	while(cin>>N){
			N+=1;
			int tempx,tempy;int p[N+1];int flag=1;
			for(int i=1;i<N;i++){
				cin>>tempx>>tempy;
				if(i==1){
					p[0]=tempx;p[1]=tempy;
				}else{
					if(tempx!=p[i-1]) {
						cout<<"invalid argument"<<endl;
						flag=0;break;
					}
				}
				p[i]=tempy;
			}
		if(flag==0) continue; 
    int **s = new int *[N];
	for(int i=0;i<N;i++)  
    {  
		s[i] = new int[N];  
    } 
    cout<<RecurMatrixChain(1,N-1,s,p)<<endl;
	//cout<<"矩阵的最少计算次数为："<<RecurMatrixChain(1,N-1,s,p)<<endl;
	//cout<<"矩阵最优计算次序为："<<endl;
	//Traceback(1,N-1,s);
	}
	return 0;
}

参考算法3：备忘录法优化（据说也存在错误？）

#include <iostream>
#include <cstdio>
#include <cstring>
#define SIZE 1000
#define INF 999999999
using namespace std;

int memo[SIZE][SIZE];
//m数组内存放矩阵链的行列信息
//m[i-1]和m[i]分别为第i个矩阵的行和列（i = 1、2、3...）
int Best_Memo(int m[], int left, int right)
{
	//只有一个矩阵时，返回计算次数0
	if (left == right)
	{
		return 0;
	}
 
	double min = INF;
	int i;
	//括号依次加在第1、2、3...n-1个矩阵后面
	for (i = left; i < right; i++)
	{
		//计算出这种完全加括号方式的计算次数
		double 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 (cin>>n)
	{
		int i;n++;int tempx,tempy,flag=1;
		for(i=1;i<n;i++){
			cin>>tempx>>tempy;
			if(i==1){
				m[0]=tempx;m[1]=tempy;
			}else{
				if(tempx!=m[i-1]) {
					cout<<"invalid argument"<<endl;
					flag=0;break;
				}
			}
				m[i]=tempy;
		}
		if(flag==0) continue;
		memset(memo, 0, sizeof(memo));
		printf("%d\n", Best_Memo(m, 1, n-1));
	}
	return 0;
}

参考算法4：

#include<iostream>
#include<vector>
using namespace std;
int N;
int matrixMultiple(int n, vector< vector<int> > &m, vector< vector<int> > &s, int p[]){

    for(int i = 1; i < n; i++){  
        //对角线设为0，没有自己和自己乘
        m[i][i] = 0;
    }

    for(int r = 2; r <= n; r++){ //r为规模

        for(int i = 1; i <= n-r+1; i++){  //i:首矩阵编号

            int j = i + r - 1;  //尾矩阵编号
            m[i][j] = m[i+1][j] + p[i-1]*p[i]*p[j];    //将链ij划分为A(i) *(A[i+1 : j])
            s[i][j] = i;
            
            for(int k = i + 1; k < j; k++){  //k:断开的位置
                //将链ij划分为(A[i:k] + A[k+1 : j])
                int temp = m[i][k] + m[k + 1][j] + p[i-1]*p[k]*p[j];
                if(temp < m[i][j]){
                    m[i][j] = temp;
                    s[i][j] = k;
                }
            }
        }
    }
    return m[1][N-1];
}

int main(){
	int x;
	while (cin>>x)
		{
			int i;N=x+1;int tempx,tempy,flag=1;
			int p[N];
			for(i=1;i<N;i++){
				cin>>tempx>>tempy;
				if(i==1){
					p[0]=tempx;p[1]=tempy;
				}else{
					if(tempx!=p[i-1]) {
						cout<<"invalid argument"<<endl;
						flag=0;break;
					}
				}
					p[i]=tempy;
			}
			if(flag==0) continue;
    vector< vector<int> > m(N, vector<int>(N));
    vector< vector<int> > s(N, vector<int>(N));
 
 	cout<<matrixMultiple(N-1,m,s,p)<<endl;
	//cout<<"矩阵的最少计算次数为："<<matrixMultiple(N-1,m,s,p)<<endl;
	
}
return 0;
}

参考文章：

算法之矩阵连乘问题_伊二的博客-CSDN博客_矩阵连乘算法

矩阵连乘问题——算法笔记——详解_越前浩波的博客-CSDN博客_矩阵连乘问题

0010算法笔记——【动态规划】矩阵连乘问题_风仲达的博客-CSDN博客_矩阵连乘问题的动态规划算法

矩阵连乘（动态规划算法）_何智鹏的博客-CSDN博客_矩阵连乘动态规划