动态规划学习笔记——关于矩阵连乘的理解。

矩阵连乘的主要要解决的问题为解决：给定一组矩阵相乘，优化其运算顺序，使其进行乘法运算的次数最少。

解决该问题运用到了经典的动态规划的算法，解释题目前先来解释一下动态规划的基本概念和本题中用到的矩阵的乘法性质。

动态规划的基本概念

动态规划的思想与分治类型，就是把大的问题分解成有相同性质的更小的问题来解决。但是与分治不同的是：
1.分治的子问题是相互独立的，而动态规划的子问题之间是有一定联系的；
2.分治是自上到底的解决方式，即按照解决大问题的方式去结局小问题，最终完成解决大问题的目的。动态规划时自底向上的解决方式，即先解决规模较小的问题得到最优解，一步步向上运算，最终得到大问题的最优解。

动态规划的两大要素

1.最优子结构性质：问题的最优解包含其子问题的最有解。
2.重叠子问题：利用递归算法，每次产生的子问题并不是新问题，可能会用到其他更小子问题运算得到的结果。

矩阵的乘法性质

1.矩阵的乘法可以结合律不可以用交换律；
2.被乘矩阵的列数一定等于所乘矩阵的行数。例，A[3,5]B[5,3]
3.矩阵A[i,j]A[j,k]进行运算的次数为ijk。
4.A[i][j]*B[j][k]=C[i][k]
了解这四条条性质即可解决本题，其他性质请查阅相关资料。

矩阵连乘问题详解

定义没看明白没关系，下面结合矩阵连乘的详细案例。本问题的具体思想就是先从底层算起，最终得出问题的最优解。
例如要求六个矩阵｛A1 A2 A3 A4 A5 A6｝的连乘问题：
1.首先建立一个矩阵m[6][6],来储存结果，例如m[2][4],代表从A2 A3 A4连乘的最小乘法次数。根据矩阵的性质建立一个数组p[7]储存各矩阵的行列值。例如p[0],p[1],代表A1的行列值，p[1][2]代表A2的行列值。

2.求出相邻两个矩阵相乘要运算的乘法的最优解，即计算没相邻两个矩阵的乘法次数，例如A1A2,A2A3…A5.A6。并将结果保存在m中

3.求出相邻三两个矩阵相乘要运算的乘法的最优解，例如A1A2A3。现在，我们发现我不能像第一步那样直接求了，因为(A1A2)A3和A1(A2A3)的结果很大概率是不同，所以我们要运算两次，得出最小数存在m[1][3]中（最优子结构性质）。我们刚才求的A1A2值现在也可以派上用场了（重叠子问题性质）。

比如求(A1A2)A3的乘法次数
=A1A2的乘法次数+A1A2的出的矩阵的行坐标列坐标A3*列坐标

=m[1][2]+A1的行坐标A2的列坐标A3的列坐标

=m[1][2]+p[0]*p[2]*p[3]

4.同3求出相邻4求出相邻三两个矩阵相乘要运算的乘法的最优解；
…
得出六个矩阵连乘的最小值。

下面是C++代码

#include<iostream>
using namespace std;
#define N 6
void MatrixChain(int *p,int n,int m[][N+1],int s[][N+1]){
	//A[i][i]等数为0;
	for(int i=0;i<=n;i++){
		m[i][i]=0;
	}

	for(int r = 2;r<=n;r++){
		//r为要计算的矩阵的长度
		//从2开始计算到最大长度
		for(int i=1;i<=n-r+1;i++){

			//i为要计算的子序列的
			int j=i+r-1;

			/*
			按正常顺序算出吗m[i][k]的值
			列如{a1,a2,a3}
			m[1][3]=m[2][3]+数
			即顺序a1*(a2*a3)的计算次数

			列如{a1,a2,a3,a4}
			m[1][4]=m[2][4]+数
			即a1*(a2*a3*a4)序列的乘法次数
			*/
			m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j];

			/*
			记录Aij可以划分成哪两个序列相乘
			例如s[1][6]=3点，代表将1-6划分成两部分
			1-3一组，4-6一组
			*/
			s[i][j]=i;

			/*
			检测从i到j的子序列是否还有更小的值
			列如{A1,A2,A3,A4}
			要求下列乘法顺序的乘法次数
			(A1*A2)*(A3*A4)
			(A1*A2*A3)*A4 
			*/
			for(int k=i+1;k<j;k++){
				/*
				关于对p[i-1]*p[k]*p[j]的理解
				矩阵的行列大小，肯定是首位的行数和末尾的列数
				k为被乘数的行数
				列如(A1*A2)*(A3*A4)
				k即为A3的行数，或A1*A2的列数，或A2的列数
				*/
				int t=m[i][k]+m[k+1][k]+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+1]){
	if(i==j)return;
	/*
	若能分解成更小的的序列，则先输入更小的寻别上的值
	*/
	TraceBack(i,s[i][j],s);
	TraceBack(s[i][j]+1,j,s);
	cout<<"Multiply A"<<i<<","<<s[i][j]
	<<" and A"<<(s[i][j]+1)<<","<<j<<endl;
}

int main(){
	int p[N+1]={30,35,15,5,10,20,25};
	int m[N+1][N+1] = {0},s[N+1][N+1]={0};

	MatrixChain(p,N,m,s);
	cout<<"要进行的最大次数运算为："<<m[1][N]<<endl;

	TraceBack(1,6,s);
	int n;
	cin>>n;
	return 0;
}