动态规划_矩阵连乘问题

最新推荐文章于 2020-07-24 21:49:00 发布

原创最新推荐文章于 2020-07-24 21:49:00 发布 · 405 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划 #矩阵连乘 #java

Java 专栏收录该内容

39 篇文章

订阅专栏

本文介绍了一种使用动态规划解决矩阵链乘法优化问题的方法。通过计算不同矩阵链的最优乘法顺序来减少不必要的运算，从而提高计算效率。文章提供了一个具体的实现示例，并展示了如何通过递归方式获取最优计算顺序。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/**
 * 动态规划_矩阵连乘问题
 * @author Matt
 *
 */
public class Dp {

    /**
     * 矩阵链计算
     * @param p 矩阵的长度
     * @param m 矩阵的最优连乘次数
     * @param s 矩阵的最优断开位置
     */
    public static void matrixChain(int []p, int [][]m, int [][]s) {
        // n是矩阵的长度
        int n = p.length - 1;
        // 将对角线的最优次数置0，因为m[i][i]的连乘次数为0
        for (int i = 1; i <= n; i++) {
            m[i][i] = 0;
        }
        // r是矩阵链的长度，有r个矩阵相乘
        for (int r = 2; r <= n; r++) {
            for (int i = 1; i <= n-r+1; i++) {
                int j = i+r-1; // j是矩阵链的最后一个矩阵的坐标
                // 计算连乘次数，i为断开处
                m[i][j] = m[i+1][j] + p[i-1]*p[i]*p[j];
                s[i][j] = i; // 将断开坐标i传入s数组
                // 计算最优连乘次数
                for (int k = i+1; k < j; k++) {
                    int t = m[j][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; // 求得最优断开位置
                    }
                }
            }
        }
    }

    /**
     * 回溯递归求得最优计算次序
     * @param s 断开位置数组
     * @param i 行
     * @param 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("Multiply A" + i + "," + s[i][j] +
                "and A" + (s[i][j] + 1) + "," + j);
    }

    public static void main(String[] args) {
        int[] p = {30, 35, 15, 5, 10, 20, 25}; // 矩阵维度
        int n = p.length;
        int[][] m = new int[n][n];
        int[][] s = new int[n][n];
        matrixChain(p, m, s);
        traceBack(s, 1, n-1);
    }

}