15.2：分金条的最小代价

一块金条切成两半，是需要花费和长度数值一样的铜板
比如长度为20的金条，不管怎么切都要花费20个铜板，一群人想整分整块金条，怎么分最省铜板?
例如，给定数组{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铜板
输入一个数组，返回分割的最小代价.

大纲：

package algorithmbasic.class15;

import java.util.*;

/*
一块金条切成两半，是需要花费和长度数值一样的铜板
比如长度为20的金条，不管怎么切都要花费20个铜板，一群人想整分整块金条，怎么分最省铜板?
例如，给定数组{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铜板
输入一个数组，返回分割的最小代价.
 */
public class LessMoneySplitGold {

    //暴力方法
    public static int lessMoney1(int[] arr) {}

    

    //贪心方法
    public static int lessMoney2(int[] arr) {}
    
    

    // ---------------------- for test ------------------------
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * (maxValue + 1));
        }
        return arr;
    }

    public static void main(String[] args) {
        int testTime = 100000;
        int maxSize = 6;
        int maxValue = 1000;
        for (int i = 0; i < testTime; i++) {
            int[] arr = generateRandomArray(maxSize, maxValue);
            if (lessMoney2(arr) != lessMoney1(arr)) {
                System.out.println("Oops!");
            }
        }
        System.out.println("finish!");
    }
}

贪心解法

哈夫曼树：https://zhuanlan.zhihu.com/p/54714101

哈夫曼树只保证一件事情：非叶节点的总和最小。

因为一个非叶节点就是一次合并的花费。所以只要所有非叶节点的总和最小，那就是整体的费用最小。

其他什么也不保证，就保证这个。哈夫曼树可以做到这一点。

创建一个小根堆，让所有的数据入堆，

一次弹出两个元素，求两个元素之和sum,这个sum即：合并出的结果就是我们要的花费。

全局变量count += sum，来记录全局最小花费。

再将sum放入小根堆中

重复以上操作，直至小根堆中只剩一个元素结束。

	public static int lessMoney2(int[] arr) {
        //1:创建一个小根堆
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        //2：入堆
        for (int i = 0; i < arr.length; i++) {
            heap.add(arr[i]);
        }
        //3:一次弹出两个，进行相加，得到的结果进行标注一下，然后再存放在堆中。直到堆里只剩下一个元素循环才停止。
        int count = 0;
        while (heap.size() > 1) {
            int cur = heap.poll() + heap.poll();//注意空指针异常。
            count += cur;
            heap.add(cur);
        }
        //4:对特殊标注进行相加
        return count;
    }

暴力解法

注意：合并出的结果才是我们需要的花费。

倒着合并，正着分开。合并时的花费 == 正着分开时的花费。

public static int lessMoney1(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        return process(arr, 0);
    }

    //构造一个函数：
    //等待合并的数都放在arr数组里
    //之前合并产生的总的最小代价是pre
    //返回值的意义是：返回整体最小的。
    public static int process(int[] arr, int pre) {
        if (arr.length == 1) {// 说明都合并完了。
            return pre;
        }
        int ans = Integer.MAX_VALUE;
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                //process(copyAndMergeTwo(arr, i, j), pre + arr[i] + arr[j]):会返回一个整体的最小值。
                //这个整体的最小值会因为i,j的选择不同从而值不同。因此我们要选出一个最小的。
                ans = Math.min(ans, process(copyAndMergeTwo(arr, i, j), pre + arr[i] + arr[j]));
            }
        }
        return ans;
    }

    /**
     * @copyAndMergeTwo 传进一个数组以及这个数组上的两个指针，删除两个指针指向的内容，添加两指针指向的内容之和，
     * 然后再将剩下的内容拷贝一份返回一个新数组。
     */
    public static int[] copyAndMergeTwo(int[] arr, int i, int j) {
        int[] ans = new int[arr.length - 1];
        int index = 0;
        for (int k = 0; k < arr.length; k++) {
            if (k != i && k != j) {
                ans[index++] = arr[k];
            }
        }
        ans[index] = arr[i] + arr[j];
        return ans;
    }