动态规划 java 矩阵连乘

矩阵连乘是经典的动态规划问题，第一点一定要注意44行的dp[][]提前赋值的关键点，不然无法与后边的循环出的作比较，得到最优解；第二点就是走一遍输出最有括号化最优解时，新手对于这个递归过程矩阵可能不是很熟悉（当然我也是小白，），一定要通过debug一步一步的走下来，弄明白，另外就是这个问题与石子问题类似，最后有链接；

package my;

import java.util.Scanner;

/*有n个矩阵，大小分别为a0*a1, a1*a2, a2*a3, ..., a[n-1]*a[n]，
 现要将它们依次相乘，只能使用结合率，求最少需要多少次运算。　
 两个大小分别为p*q和q*r的矩阵相乘时的运算次数计为p*q*r。*/

public class jzlc {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] m = new int[n + 1];// 储存矩阵的数组
        int[][] dp = new int[n + 1][n + 1];// 储存最短步数的数组
        int[][] s = new int[n + 1][n + 1];// 储存分割点的数组
        // 键盘输入矩阵
        for (int i = 0; i < n + 1; i++)
            m[i] = scanner.nextInt();
        scanner.close();
        fun(m, dp, s, n);
        fun1(s, 1, n);
        System.out.print("最短步数为：" + dp[1][n]);

    }

    // 输出最短计算步数的括号化方案
    private static void fun1(int[][] s, int i, int j) {
        if (i == j)
            System.out.print("A" + i);
        else {
            System.out.print("(");
            fun1(s, i, s[i][j]);
            fun1(s, s[i][j] + 1, j);
            System.out.print(")");
        }
    }

    // 计算最短步数和分割点的数组
    private static void fun(int[] m, int[][] dp, int[][] s, int n) {
        int j = 0, temp = 0;
        for (int len = 2; len <= n; len++) {
            for (int i = 1; i <= n - len + 1; i++) {
                j = i + len - 1;
                dp[i][j] = dp[i + 1][j] + m[i - 1] * m[i] * m[j];
                s[i][j] = i;
                for (int k = i ; k < j; k++) {
                    temp = dp[i][k] + dp[k + 1][j] + m[i - 1] * m[k] * m[j];
                    if (temp < dp[i][j]) {
                        dp[i][j] = temp;
                        s[i][j] = k;
                    }
                }
            }
        }

    }

}