【算法】Minimum Cost Tree From Leaf Values 叶值的最小代价生成树

Minimum Cost Tree From Leaf Values 叶值的最小代价生成树

问题描述：

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

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

如果一个节点有 0 个子节点，那么该节点为叶节点。

arr.length 范围[2,40], arr[i] 范围[1,15],最终结果不超过2^31

分析

节点的数量限制在[2,40],节点值范围在[1,15]
arr中的每个元素都是树的leaf，非叶子节点的值是由leftchildmax和rightchildmax的乘积得到的。
而要求的生成树的代价，则是所有非叶子节点的累加和。
同时要求arr的顺序和生成树的inorder一致。

暴力的思路就是枚举所有可能的子树。数据的范围不大理论上可以。
如果用$f[i][j]$表示 区间i~j生成树的最小代价，那么状态转移就是
$f[i][j]=min(f[i][k]+f[k+1][j]+C),i=<k<=j-1$, C 表示 i ~ k的最大值a,k+1 ~ j的最大值b,C = a*b;
很明显$f[i][j]=0$,同时还需要维护一个记录区间最大值的矩阵，可以快速得到C。
时间复杂度O($N^3$)

如果使用另一个角度思考，如何构造一个代价最小的生成树，就有点接近哈夫曼树的思维。
对于一个叶子a[i]，它的父节点fa的产生，只有2个选择，$a[i]$与a[0 ~ i-1]的max乘积，或者是a[i]与a[i+1 ~ n-1]的max乘积。
如果a[i]是一个较大的值，那么要使得0 ~ i的生成树代价最小，a[i]就应该尽可能的靠近root[0 ~ i]的根部，这样产生的生成树代价，一定不会大于a[i]距离根部较远的生成树。
也就是说，a[i]如果较小，它应该优先用来构建子树，这样a[i]距离根部较远，a[i]应该与左边的还是右边的构建子树，因为先参与构建的节点，最后一定是距离根部远的，那么这个节点会在子树的区间逐渐变大的过程中，可能参与其他非叶子节点的构建，所以应该选择a[i] 两侧中，还为参与构建的最小叶子结点，同时要满足a[i]是<=2侧节点。
所以使用单调递减栈。

代码

public int mctFromLeafValues(int[] arr) {
        int n = arr.length;
        int[][] m = new int[n+1][n+1];//0~n  
        // f[i][j] =f[i][k]+f[k+1][j]+m[i][k]*m[k+1][j]
        int[][] f = new int[n+1][n+1];
        // 非叶子节点的sum
        int INF = Integer.MAX_VALUE>>1;
        for(int i = 0;i<n;i++){
            Arrays.fill(f[i],INF); 
        }
        for(int len=1;len<=n;len++){
            for(int i = 0;i<n;i++){
                m[i][i] = arr[i];
                f[i][i]=0;
                int j = len+i-1;
                if(j>=n) break;
                int tmp = INF,mt = 0;                
                for(int k = i;k+1<=j;k++){
                    mt = Math.max(mt,Math.max(m[k+1][j],m[i][k]));
                    int c = m[i][k]*m[k+1][j];
                    int p =f[i][k]+f[k+1][j]+c;
                    tmp = Math.min(tmp,p);
                } 
                m[i][j] = Math.max(mt,m[i][j]);
                f[i][j] = Math.min(tmp,f[i][j]); 
            } 
        }
        return f[0][n-1];
    }

时间复杂度 O($N^3$) 空间复杂度： O($N^2$)

单调栈

public int mctFromLeafValues(int[] arr) {
        int res = 0;
        Deque<Integer> stk = new ArrayDeque<Integer>();
        for (int x : arr) {
            while (!stk.isEmpty() && stk.peek() <= x) {
                int y = stk.pop();
                if (stk.isEmpty() || stk.peek() > x) {
                    res += y * x;
                } else {
                    res += stk.peek() * y;
                }
            }
            stk.push(x);
        }
        while (stk.size() >= 2) {
            int x = stk.pop();
            res += stk.peek() * x;
        }
        return res;
    } 

时间复杂度 O(N) 空间复杂度： O(N)

Tag

Array Dynamic Programming Monotonic Stack