矩阵连乘动态规划算法

矩阵连乘动态规划算法

题目描述：

Java实现：

import java.util.Scanner;

public class MatrixChain {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int p[] = new int[n+1];
        for(int i=0; i<=n; i++)
            p[i] = scan.nextInt();
//      int n = 6;
//      int p[] = {30, 35, 15, 5, 10, 20, 25};
        //非递归
        int m[][] = new int[n+1][n+1];
        int s[][] = new int[n+1][n+1];
        MatrixChain1(p, n, m, s);
        t(1, n, s);
        System.out.println();
        String sss = traceBack(1, n, s);
        System.out.println(sss);
        //自底向上 递归 动态规划
        int s1[][] = new int[n+1][n+1];
        RecurMatrixChain(1, n, p, s1);
        t(1, n, s1);
        System.out.println();
        //自顶向下 递归 动态规划
        int m2[][] = new int[n+1][n+1];
        int s2[][] = new int[n+1][n+1];
        MemoizedMatrixChain(n, m2, s2, p);
        t(1, n, s2);
    }
    //输出计算最优计算次序,括号分离
    public static void t(int i, int j, int s[][]) {
        if (i == j)
            System.out.print("A" + i);
        else {  
            System.out.print("(");
            t(i, s[i][j], s);
            t(s[i][j]+1, j, s);
            System.out.print(")");
        }
    }
    public static String traceBack(int i,int j,int s[][]){
        if(i==j){
              return "A"+i;
        }
        else{
               return"("+traceBack(i,s[i][j],s)+traceBack(s[i][j]+1,j,s)+")";
        }
    }
    //非递归方法
    //一维数组P存储n个矩阵的行列值, 二维数组m存储最优值, 二维数组s记录最优断开位置
    public static void MatrixChain1(int p[], int n, int m[][], int s[][]){
        for(int i=1; i<=n; i++)//单个矩阵
            m[i][i] = 0;
        for(int r=2; r<=n; r++){//多个矩阵
            for(int len=1; len<=n-r+1; len++){
                int j = len + r -1;
                m[len][j] = m[len+1][j] +p[len-1]*p[len]*p[j];
                s[len][j] = len;
                for(int k=len+1; k<j; k++){
                    int t = m[len][k] + m[k+1][j] + p[len-1]*p[k]*p[j];
                    if(t < m[len][j]){
                        m[len][j] = t;
                        s[len][j] = k;
                    }
                }
            }
        }
    }   
    //一维数组P存储n个矩阵的维数值, 二维数组s记录最优断开位置
    //自底向上 递归 动态规划
    public static int RecurMatrixChain(int i, int j, int p[], int s[][]) {
        if(i==j) return 0;
        int u = RecurMatrixChain(i, i, p, s) + RecurMatrixChain(i+1, j, p, s) + p[i-1]*p[i]*p[j];
        s[i][j] = i;
        for(int k=i+1; k<j; k++){
            int t = RecurMatrixChain(i, k, p, s) + RecurMatrixChain(k+1, j, p, s) + p[i-1]*p[k]*p[j];
            if(t < u){
                u = t;
                s[i][j] = k;
            }
        }
        return u;
    }
    //一维数组P存储n个矩阵的维数值, 二维数组m存储最优值, 二维数组s记录最优断开位置
    //自顶向下 递归 动态规划(备忘录方法)
    public static int MemoizedMatrixChain(int n, int m[][], int s[][], int p[]) {
        for(int i=1; i<=n; i++)
            for(int j=i; j<=n; j++)
                m[i][j] = 0;
        return LookupChain(1, n, m, s, p);
    }
    public static int LookupChain(int i, int j, int m[][], int s[][], int p[]){
        if(m[i][j] > 0) return m[i][j];
        if(i==j) return 0;
        int u = LookupChain(i, i, m, s, p) + LookupChain(i+1, j, m, s, p) + p[i-1]*p[i]*p[j];
        s[i][j] = i;
        for(int k=i+1; k<j; k++){
            int t = LookupChain(i, k, m, s, p) + LookupChain(k+1, j, m, s, p) + p[i-1]*p[k]*p[j];
            if(t < u){
                u = t;
                s[i][j] = k;
            }
        }
        m[i][j] =u;
        return u;
    }

}