动态规划解决矩阵链乘问题的java编码实现

来源：互联网发布：python pdfkit 编辑：程序博客网时间：2024/04/28 15:06

算法实现了三个类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);

}

}}