JAVA程序设计：叶值的最小代价生成树（LeetCode：1130）

给你一个正整数数组 arr，考虑所有满足以下条件的二叉树：

每个节点都有 0 个或是 2 个子节点。
数组 arr 中的值与树的中序遍历中每个叶节点的值一一对应。（知识回顾：如果一个节点有 0 个子节点，那么该节点为叶节点。）
每个非叶节点的值等于其左子树和右子树中叶节点的最大值的乘积。
在所有这样的二叉树中，返回每个非叶节点的值的最小可能总和。这个和的值是一个 32 位整数。

 

示例：

输入：arr = [6,2,4]
输出：32
解释：
有两种可能的树，第一种的非叶节点的总和为 36，第二种非叶节点的总和为 32。

    24            24
   /  \          /  \
  12   4        6    8
 /  \               / \
6    2             2   4
 

提示：

2 <= arr.length <= 40
1 <= arr[i] <= 15
答案保证是一个 32 位带符号整数，即小于 2^31。

思路：区间dp,在我的代码中，sum[i][j]代表区间[i,j]能组成的最小和，dp[i][j]用来保存将区间[i,j]分成两部分时的两个子数组最大值的乘积。最后别忘了减去叶子节点的值哦。

class Solution {
    public int mctFromLeafValues(int[] arr) {

        int ans = 0;
        int n = arr.length;
        int[][] dp = new int[n][n];
        int[][] mx = new int[n][n];
        int[][] sum = new int[n][n];

        for (int i = 0; i < n; i++) {
            mx[i][i] = arr[i];
            for (int j = i + 1; j < n; j++) {
                sum[i][j] = dp[i][j] = Integer.MAX_VALUE;
                mx[i][j] = Math.max(mx[i][j - 1], arr[j]);
            }
        }

        for (int i = 0; i < n; i++)
            sum[i][i] = dp[i][i] = arr[i];

        for (int len = 1; len <= n; len++)
            for (int i = 0; i + len - 1 < n; i++) {
                int j = i + len - 1;
                for (int k = i; k < j; k++) {
                    if (dp[i][k] == Integer.MAX_VALUE || dp[k + 1][j] == Integer.MAX_VALUE)
                        continue;
                    if (sum[i][j] > mx[i][k] * mx[k + 1][j] + sum[i][k] + sum[k + 1][j]) {
                        dp[i][j] = mx[i][k] * mx[k + 1][j];
                        sum[i][j] = dp[i][j] + sum[i][k] + sum[k + 1][j];

                    }
                }
            }

        for (int i = 0; i < n; i++)
            sum[0][n - 1] -= dp[i][i];

        return sum[0][n - 1];

    }
}