Java 动态规划矩阵链乘法

我在读动态规划中的矩阵链乘法， 它有一个简单的递归解决方案，具有指数级的运行时间

虽然有动态程序。解决方案（上面链接中的代码）的运行时复杂性为O（n^3），但如果我们保留一个2d数组来存储重叠子问题的结果，它的运行时是否与dp解决方案相同

public class MatrixChain {

    public static void main(String... args) throws IOException {
        new MatrixChain().job();
    }

    private void job() {
        int arr[] = new int[]{40, 20, 30, 10, 30};
        int[][] dp = new int[5][5];
        for (int[] x : dp)
            Arrays.fill(x, -1);
        int min = findMin(arr, 1, arr.length - 1, dp);
        System.out.println(min);
    }

    private int findMin(int[] arr, int i, int j, int dp[][]) {
        if (i == j) return 0;
        int min = Integer.MAX_VALUE;
        for (int k = i; k < j; k++) {
            int fp;
            if (dp[i][k] == -1)
                dp[i][k] = fp = findMin(arr, i, k, dp);
            else fp = dp[i][k];
            int lp;
            if (dp[k + 1][j] == -1)
                dp[k + 1][j] = lp = findMin(arr, k + 1, j, dp);
            else
                lp = dp[k + 1][j];

            int sum = fp + lp + arr[i - 1] * arr[k] * arr[j];
            if (sum < min)
                min = sum;
        }
        return min;
    }
}

公共类矩阵链{
公共静态void main（字符串…参数）引发IOException{
新矩阵链（）.job（）；
}
私人职位（）{
int arr[]=新的int[]{40,20,30,10,30}；
int[]dp=新int[5][5]；
对于（int[]x:dp）
数组。填充（x，-1）；
int min=findMin（arr，1，arr.length-1，dp）；
系统输出打印项次（最小值）；
}
私有int findMin（int[]arr、int i、int j、int dp[]{
如果（i==j）返回0；
int min=整数最大值；
对于（int k=i；k

---

谢谢

是的，会的。无论是迭代还是递归编写函数。重要的是，你要记住你的结果。而你就是这样

虽然我有一些优化：

private int findMin(int[] arr, int i, int j, int dp[][]) {
    if (i == j) 
        return 0;

    /* Immediate look-up in dp */
    if (dp[i][j] != -1)
        return dp[i][j];

    /* Otherwise compute the number, much shorter since you don't
       have to worry about reading from dp and saving it to dp. */
    int min = Integer.MAX_VALUE;
    for (int k = i; k < j; k++) {
        int fp = findMin(arr, i, k, dp);
        int lp = findMin(arr, k + 1, j, dp);
        int sum = fp + lp + arr[i - 1] * arr[k] * arr[j];
        if (sum < min)
            min = sum;
    }

    /* Now save the result */
    dp[i][j] = min;
    return min;
}

private int findMin（int[]arr，int i，int j，int dp[]{
如果（i==j）
返回0；
/*dp中的即时查找*/
如果（dp[i][j]！=-1）
返回dp[i][j]；
/*否则，计算数字，因为您不需要
必须担心从dp读取数据并将其保存到dp*/
int min=整数最大值；
对于（int k=i；k

Dude，

geeksforgeks

是一个非常高质量的博客。您可以信任放置在那里的每一行代码！