算法：矩阵连乘(Java)动态规划

Description

给你2个矩阵A、B，我们使用标准的矩阵相乘定义C=AB如下：

例如：X、Y、Z都是矩阵，要计算XYZ的话可以有2种选择：(XY)Z 或者 X(YZ)。

假设X是5x10的数组，Y是10x20的数组，Z是20x35的数组，那个不同的运算顺序所需的乘法数会有不同：

(XY)Z

• 5 * 20 * 10 = 1000次乘法完成(XY)，并得到一5x20的数组。
• 5 * 35 * 20 = 3500次乘法得到最后的结果。
• 总共需要的乘法的次数：1000+3500=4500。

X(YZ)

• 10 * 35 * 20 = 7000次乘法完成(YZ)，并得到一10x35的数组。
• 5 * 35 * 10 = 1750次乘法得到最后的结果。
• 总共需要的乘法的次数：7000 +1750 = 8750。

很明显的，我们可以知道计算(XY)Z会使用较少次的乘法。 这个问题是：给你一些矩阵，你要写一个程序来决定该如何相乘的顺序，使得用到乘法的次数会最少。

Input

含有多组测试数据，每组测试数据的第一列，含有1个整数N（N <= 10）代表有多少个数组要相乘。接下来有N对整数，代表一数组的列数及栏数。这N个数组的顺序与要你相乘的数组顺序是一样的。N=0代表输入结束。请参考Sample Input。

Output

每组测试数据输出一列，内容为矩阵相乘的顺序（以刮号来表示）使得所用的乘法次数最小。如果有不只一组答案，输出任一组均可。请参考Sample Output。

Sample Input

3
1 5
5 20
20 1
3
5 10
10 20
20 35
6
30 35
35 15
15 5
5 10
10 20
20 25
0

Sample Output

Case 1: (A1 x (A2 x A3))
Case 2: ((A1 x A2) x A3)
Case 3: ((A1 x (A2 x A3)) x ((A4 x A5) x A6))

递归关系:
m [ i ] [ j ] = { 0   i = = j min ⁡ i ≤ k < j { m [ i ] [ k ] + m [ k + 1 ] [ j ] + p i − 1 ∗ p k ∗ p j }   i < j m[i][j] = \begin{cases} 0 &\ i == j \\ \min_{i \le k \lt j} \{ m[i][k] + m[k+1][j] + p_{i-1}*p_k*p_j \} &\ i<j \end{cases} m[i][j]={0mini≤k<j​{m[i][k]+m[k+1][j]+pi−1​∗pk​∗pj​}​ i==j i<j​
数组m[n][n]存储最优值

数组s[n][n]存储最优时分割的位置

import java.util.Scanner;

public class Main {
    static int count = 0;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int p[], m[][], s[][];
        while (sc.hasNextInt()) {
            int n = sc.nextInt();
            if (n == 0)
                break;
            p = new int[n + 1];
            m = new int[n + 1][n + 1];
            s = new int[n + 1][n + 1];

            for (int i = 0; i < n; i++) {
                p[i] = sc.nextInt();
                p[i + 1] = sc.nextInt();
            }
            matrixChain(p, m, s);
            System.out.printf("Case %d: ", ++count);
            print(1, n, s);
            System.out.print('\n');
            // printmAnds(n, m, s);
        }
        sc.close();
    }

    public static void matrixChain(int p[], int m[][], int s[][]) {
        int n = p.length - 1;
        for (int i = 1; i <= n; i++)
            m[i][i] = 0;
        for (int r = 2; r <= n; r++) {
            for (int i = 1; i <= n - r + 1; i++) {
                int j = i + r - 1;
                m[i][j] = m[i + 1][j] + p[i - 1] * p[i] * p[j];
                s[i][j] = i;
                for (int k = i + 1; k < j; k++) {
                    int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
                    if (t < m[i][j]) {
                        m[i][j] = t;
                        s[i][j] = k;
                    }
                }
            }
        }
    }

    public static void print(int i, int j, int s[][]) {
        if (i == j) {
            System.out.print("A" + i);
            return;
        }
        else {
            System.out.print("(");
            print(i, s[i][j], s);
            System.out.print(" x ");
            print(s[i][j] + 1, j, s);
            System.out.print(")");
        }
    }
//    public static void printmAnds(int n, int m[][], int s[][]){
//        System.out.printf("m[%d][%d]: \n", n, n);
//        for (int i = 1; i <= n; i++) {
//            System.out.print(m[i][1]);
//            for (int j = 2; j <= n; j++) {
//                System.out.print("\t" + m[i][j]);
//            }
//            System.out.print('\n');
//        }
//
//        System.out.printf("s[%d][%d]: \n", n, n);
//        for (int i = 1; i <= n; i++) {
//            System.out.print(s[i][1]);
//            for (int j = 2; j <= n; j++) {
//                System.out.print("\t" + s[i][j]);
//            }
//            System.out.print('\n');
//        }
//    }
}