算法实现了三个类Matrix, MatrixChainOrder, MatrixArray
在Matrix类中实现了矩阵的随机产生和两个矩阵的相乘
在MatrixArray中实现了矩阵链的随机产生和根据矩阵链随机产生矩阵,矩阵的连续相乘和矩阵链根据动态规划产生的最优相乘方法相乘
在MatrixChainOrder中实现了矩阵链乘的最优解
程序可直接编译运行,其中经过测算当矩阵为1000个元素取值为100之内是时间相差大约100000毫秒,当矩阵为100个是两个运行时间不一定哪个大。可见矩阵数目越多,效率提升越明显
import java.util.*;
public class MatrixChainOrder {
private double m[][];
private int s[][];
public MatrixChainOrder(MatrixArray p){
int n,i,j,k,l;
double q;
n=p.getMatrixArrayLength();
m=new double[n][n];
s=new int[n][n];
for(i=0;i<n;i++){
for(j=0;j<n;j++){
s[i][j]=0;
}
}
for(i=0;i<n;i++){
m[i][i]=0;
}
for(l=2;l<n;l++){
for(i=1;i<(n-l+1);i++){
j=i+l-1;
m[i][j]=99999999999999999999.0;
for(k=i;k<j;k++){
q=m[i][k]+m[k+1][j]+p.getMatrixArray(i-1)*p.getMatrixArray(k)*p.getMatrixArray(j);
if(q<m[i][j]){
m[i][j]=q;
s[i][j]=k;
}
}
}
}
}//end of MatrixChainOrder
public double getM(int i,int j){
return m[i][j];
}
public int getS(int i,int j){
return s[i][j];
}
public static void main(String args[]){
Date date1,date2,date3;
long d1,d2,d3;
MatrixArray p;
int i,j;
double sum=1.0,k=0.0;
p=new MatrixArray(100);
p.ranMakeMatrixArray(100);
p.makeMatrixChain();
MatrixChainOrder newOrder;
newOrder=new MatrixChainOrder(p);
Matrix A,B;
date1=new Date();
d1=date1.getTime();
System.out.println(d1);
A=p.matrixMultiply(p);
date2=new Date();
d2=date2.getTime();
System.out.println(d2);
B=p.matrixChainMultiply(newOrder);
date3=new Date();
d3=date3.getTime();
System.out.println(d3);
d1=d2-d1;
d2=d3-d2;
System.out.println("普通相乘用时"+d1+"毫秒");
System.out.println("优化相乘用时"+d2+"毫秒");
}
}
class Matrix{
private int i,j;
private double matrix[][];
//初始化矩阵
public void makeMatrix(int i ,int j){
this.i=i;
this.j=j;
matrix=new double[i][j];
}
//随机生成矩阵元素
public void ranFillMatrix(int random){
int s,t;
Random ran=new Random();
for(s=0;s<i;s++){
for(t=0;t<j;t++){
matrix[s][t]=ran.nextDouble()*random;
}
}
}
//获取矩阵元素
public double getMatrix(int i,int j){
return matrix[i][j];
}
//取得矩阵的列数
public int getMatrixI(){
return i;
}
//取得矩阵的行数
public int getMatrixJ(){
return j;
}
//设定矩阵中某个元素的值
public void setMatrix(int i,int j,double value){
matrix[i][j]=value;
}
//矩阵相乘
public Matrix multiplyMatrix(Matrix matrix){
int s,t;//记录传入矩阵的维数
int start,middle,end;//矩阵运算游标
double sum;
s=matrix.getMatrixI();
t=matrix.getMatrixJ();
Matrix matrixResult=new Matrix();
matrixResult.makeMatrix(i,t);
for(start=0;start<i;start++){
for(end=0;end<t;end++){
sum=0;
for(middle=0;middle<j;middle++){
sum=sum+this.matrix[start][middle]*matrix.getMatrix(middle,end);
}
matrixResult.setMatrix(start,end,sum);
}
}
return matrixResult;
}
}
class MatrixArray{
private int matrixnum;
private int array[];
private List matrixobjectarray;
//获取矩阵
public Matrix getMatrix(int i){
return (Matrix)matrixobjectarray.get(i);
}
public MatrixArray(int i){
int j;
matrixnum=i;
array=new int[matrixnum];
}
//随机生成链乘矩阵
public void ranMakeMatrixArray(int random){
int j;
Random ran=new Random();
for(j=0;j<matrixnum;j++){
array[j]=ran.nextInt(random)+1;
}
}
//获取链乘阵的维数
public int getMatrixArray(int i){
return array[i];
}
public int getMatrixArrayLength(){
return matrixnum;
}
//产生具体的矩阵
public void makeMatrixChain(){
int i,j;
matrixobjectarray=new ArrayList();
Matrix x;
for(i=0;i<matrixnum-1;i++){
x=new Matrix();
x.makeMatrix(array[i],array[i+1]);
x.ranFillMatrix(100);
matrixobjectarray.add(i,x);
}
}
//矩阵基础乘
public Matrix matrixMultiply(MatrixArray p){
Matrix A;
int i;
A=p.getMatrix(0);
for(i=1;i<p.getMatrixArrayLength()-1;i++){
A=A.multiplyMatrix(p.getMatrix(i));
}
return A;
}
//优化解
public Matrix matrixChainMultiply(MatrixChainOrder S){
return mCM(matrixobjectarray,S,0,matrixnum-2);
}
private Matrix mCM(List A,MatrixChainOrder S,int i,int j){
Matrix x,y;
if (j>i){
x=mCM(A,S,i,S.getS(i,j));
y=mCM(A,S,S.getS(i,j)+1,j);
return x.multiplyMatrix(y);
}
return (Matrix)A.get(i);
}
}}