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

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

;              s=new int

;              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);                     }       }}