动态规划之矩阵链乘问题

本文主要介绍动态规划思想介绍矩阵链乘问题：

首先介绍会用到的几个名词：

1.完全括号化（fully parenthesized）的矩阵乘积链表示的是它是单一矩阵，或者是由两个完全括号化的矩阵乘积链的积，且已外加括号。如（A1(A2A3)、((A1A2)A3);但是(A1A2A3)则不是。

2.矩阵链乘问题（matrix-chain multiplication problem）：给定n个矩阵的链（A1A2...An），矩阵Ai的规模是pi-1Xpi（1<=i<=n）,求完全括号化方案，使得计算乘积A1A2...An所需标量乘法次数最少。

应用动态规划方法求解矩阵链的最优括号化方案，按照书中给出的四个步骤进行。

Step1：刻画一个最优解的结构特征。-------最优括号化方案的结构特征。

用符号Ai..j（i<=j）表示AiAi+1...Aj乘积的结果矩阵。i=j的时候，结果为0；当i<j的时候，则为了对AiAi+1...Aj进行完全括号化，则必须在某个Ak和Ak+1直接将矩阵链划分开（k为i<=k<j间的整数）。也就是说，对某个整数k，把计算Ai..j的代价等价于先计算Ai..k和Ak+1..j的代价，然后再加上这两个矩阵相乘的代价即可。

总之就是找下看结果的一些结构特征。

Step2：递归地定义最优解的值。-------矩阵链乘的一个递归求解方案。

对矩阵链乘法问题，可以把所有的1<=i<=j<=n确定AiAi+1...Aj的最小代价括号化方案作为子问题。令m[i,j]表示计算矩阵Ai..j所需标量乘法次数的最小值。那么原问题的最优解--计算A1..n所需的最低代价就是m[1,n]。

当i=j(i=1,2..n)时定义m[i,j]=0。

当i<j时，可以利用Step1中得到的最优子结构来计算m[i,j]，则m[i,j]=min{m[i,k]+m[k+1,j]+pi-1XpkXpj}。（i<=k<j）

此递归公式是假设最优分割点k是已知的，但是实际上并不知道，选择的k的分割位置应该是使得m[i,j]的值最小。在计算m[i,j]的时候k可以取到i,i+1,i+2...j-1等共j-i个方案，从这些方案中选出那个使得m[i,j]值小的k，作为计算m[i,j]的分割点。

Step3：计算最优解的值，通常采用自底向上的方法。

采用自底向上表格法代替基于Step2中提到的计算公式。

输入：表示n个矩阵大小规模的序列p=（p0,p1...pn），p的长度是n+1.

输出：第一个是矩阵m，m[i,j]表示计算矩阵Ai..j所需标量乘法次数的最小值。

第二个是矩阵s，s[i,j]中记录的是计算过程中取m[i,j]时k的位置，即矩阵链Ai..j最佳分割点k。

《算法导论》书上给出的伪代码如下：

1 MAXTRIX_CHAIN_ORDER(p)
2   n = length[p]-1;
3   for i=1 to n
4       do m[i][i] = 0;
5   for t = 2 to n  //t is the chain length
6        do for i=1 to n-t+1
7                      j=i+t-1;
8                      m[i][j] = MAXLIMIT;
9                      for k=i to j-1
10                             q = m[i][k] + m[k+1][i] + qi-1qkqj;
11                             if q < m[i][j]
12                                then m[i][j] = q;
13                                     s[i][j] = k;
14   return m and s;

Step4：构造最优解。

有了矩阵s，s[i,j]中记录的是计算过程中取m[i,j]时k的位置，即矩阵链Ai..j最佳分割点k。那么通过先看s
记得矩阵A1..n的分割点k，然后再分别看计算A1..k和Ak+1..n的分割位置。

输入是矩阵s和想要搜索的区域i,j。采用递归的方式打印最优解的结果，最开始的时候i=1,j=n.

《算法导论》书上给出的伪代码如下：

1   PRINT_OPTIMAL_PARENS(s,i,j)
2   if i== j
3      then print "Ai"
4   else
5      print "(";
6      PRINT_OPTIMAL_PARENS(s,i,s[i][j]);
7      PRINT_OPTIMAL_PARENS(s,s[i][j]+1,j);
8      print")";

最后附上java代码实现动态规划矩阵链乘问题：

//和伪代码中不同的是在此输入的矩阵是A0...An-1   而伪代码中是A1...An
//此处Ai的规模是p[i]*p[i+1]            而伪代码中是p[i-1]*p[i]

public static int m[][]; //m[i][j]存储计算矩阵Ai到Aj相乘的最小相乘次数
public static int s[][];//s[i][j]存储计算矩阵Ai到Aj相乘的最小相乘次数时的最佳分割点k
public static int n;//矩阵链中相乘矩阵的个数

public static void matrixChain(int p[]){
n=p.length-1;
m=new int

;
s=new int

;

for(int i=0;i<n;i++){//先把单个矩阵乘积写上，即i=j时m[i][j]=0
for(int j=0;j<n;j++){
m[i][j]=0;
}
}

for(int l=2;l<=n;l++){//l表示矩阵链乘中相乘矩阵的个数
for(int i=0;i<n-l+1;i++){
int j=i+l-1;//记录相应的j的位置
m[i][j]=999999;
int q;
for(int k=i;k<j;k++){
q=m[i][k]+m[k+1][j]+p[i]*p[k+1]*p[j+1];
if(m[i][j]>q){
m[i][j]=q;
s[i][j]=k;//记录下分割点k
}
}
}

}
}

public static void print(int s[][],int i,int j){
if(i==j){
System.out.print("A"+i);
}
else{
System.out.print("(");
print(s,i,s[i][j]);
print(s,s[i][j]+1,j);
System.out.print(")");
}
}

public static void main(String[] args){
int p[] = {30,35,15,5,10,20,25};  //输入的是表示矩阵规模的一维数组
MatrixChain.matrixChain(p);
System.out.println("一个矩阵链乘次数最少的方案");
MatrixChain.print(s, 0, n-1);
}