动态规划-3.1.3矩阵连乘问题之备忘录方法（自顶向下）

备忘录方法为每个子问题建立一个记录项，初始化时，该记录项存入一个特殊值，表示该子问题尚未解决。在求解过程中，对每个待求子问题，首先查看其相应的记录项。有变化则不算，无则算。

代码如下：

public class test3_1_3 {
    static int[] p = {30,35,15,5,10,20,25};
    static int n = p.length;
    static int[][] m = new int[n][n];
    static int[][] s = new int[n][n];
    public static int memoizedMatrixChain(int n){  //备忘录方法
        for(int i=1;i<n;i++)
            for(int j=1;j<n;j++)
                m[i][j] = 0;  //初始化未解决的问题最优值都标记为0
        return lookupChain(1,n-1);
    }
    public static int lookupChain(int i,int j){
        if(m[i][j]>0) return m[i][j]; //若m[i][j]>0,则此问题已经解决过,跳过
        if(i==j) return 0;
        m[i][j] = lookupChain(i+1,j)+p[i-1]*p[i]*p[j];
        s[i][j] = i;
        for(int k=i+1;k<j;k++){
            int t = lookupChain(i,k)+lookupChain(k+1,j)+p[i-1]*p[k]*p[j];
            if(t<m[i][j]){
                m[i][j] = t;
                s[i][j] = k;
            }
        }
        return m[i][j];
    }
    public static void traceback(int[][] s,int i,int j){
        if(i==j) return;
        traceback(s,i,s[i][j]);
        traceback(s,s[i][j]+1,j);
        System.out.println("(A"+i+"。。。"+"A"+s[i][j]+")(A"+(s[i][j]+1)+"。。。"+"A"+j+")");
    }
    public static void main(String[] args) {
        int memoized = memoizedMatrixChain(n);
        System.out.println("矩阵连乘最优值为："+memoized);
        traceback(s,1,n-1);
    }
}

运行结果如下：

矩阵连乘最优值为：15125
(A2。。。A2)(A3。。。A3)
(A1。。。A1)(A2。。。A3)
(A4。。。A4)(A5。。。A5)
(A4。。。A5)(A6。。。A6)
(A1。。。A3)(A4。。。A6)

总结：与动态规划算法不同的是，备忘录方法的递归方式是自顶向下的，而动态规划算法则是自底向上递归的。因此，备忘录方法的控制结构与直接递归方法的控制结构相同，区别在于备忘录方法为每个解过的子问题建立了备忘录以备需要时查看，避免了相同子问题的重复求解。

算法时间复杂度：O（n^3）。