算法：分割黄金的最小代价

题目描述

给定一个正数数组arr，arr的累加和代表金条的总长度，arr的每个数代表金条要分成的长度。规定长度为k的金条分成两块，费用为k个铜板。返回分割的最小代价。

例如：

• 给定数组[10,20,30]，代表一共三个人，整块金条长度为60，金条要分成10,20,30三个部分。
• 如果先把长度为60的金条分成10和50，花费60；再把长度为50的金条分成20和30，花费50；一共需要花费110个铜板。
• 但是如果先把长度为60的金条分成30和30，花费60;再把30的金条分成10和20,花费30；一共花费90个铜板。

题目分析

最小堆

本题要求合理的拆分数组，使得最终变为所要求的每个长度，反过来思考：

• 将最终的数字，两两合并，不断的两两合并最终变为一个数字
• 总的开销：每合并一次，开销为两者之和，不断的两两合并

由此可见，整个拆分过程如同二叉树展开。叶子节点就是每个分割的大小。

原理是哈夫曼树

实现：
1、准备一个小根堆
2、把所有树放到小根堆中
3、然后依次弹出两个数，求和
4、把和扔到小根堆中
循环3、4步骤

int lessMoney(std::vector<int> arr){
    std::priority_queue<int, std::vector<int>, std::greater<>> pq;
    for (int & i : arr) {
        pq.emplace(i);
    }
    int sum = 0;
    int cur = 0;
    while (pq.size() > 1){
        int v1 = pq.top(); pq.pop();
        int v2 = pq.top(); pq.pop();
        cur = v1 + v2;
        sum += cur;
        pq.emplace(cur);
    }
    return sum;
}

暴力

std::vector<int> copyAndMergeTwo(std::vector<int>  arr, int i, int j){
    std::vector<int> ans(arr.size() - 1);
    int idx = 0;
    for (int k = 0; k < arr.size(); ++k) {
        if(k != i && k != j){
            ans[idx++] = arr[k];
        }
    }
    ans[idx] = arr[i] + arr[j];
    return ans;
}


// 等待合并的数都在arr里，pre之前的合并行为产生了多少总代价
// arr中只剩一个数字的时候，停止合并，返回最小的总代价
int process(std::vector<int>  arr, int pre){
    if(arr.size() == 1){
        return pre;
    }

    int res =   INT32_MAX;
    for (int i = 0; i < arr.size(); ++i) {
        for (int j = i + 1; j < arr.size(); ++j) {
            res = std::min(res, process(copyAndMergeTwo(arr, i, j), pre + arr[i] + arr[j]));
        }
    }
    return res;
}

int lessMoney1(std::vector<int>  arr) {
    if ( arr.size() == 0) {
        return 0;
    }
    return process(arr, 0);
}